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
1843mod internal {
1844    use super::*;
1845    unsafe impl fidl::encoding::TypeMarker for ControlCodecStartError {
1846        type Owned = Self;
1847
1848        #[inline(always)]
1849        fn inline_align(_context: fidl::encoding::Context) -> usize {
1850            std::mem::align_of::<u32>()
1851        }
1852
1853        #[inline(always)]
1854        fn inline_size(_context: fidl::encoding::Context) -> usize {
1855            std::mem::size_of::<u32>()
1856        }
1857
1858        #[inline(always)]
1859        fn encode_is_copy() -> bool {
1860            false
1861        }
1862
1863        #[inline(always)]
1864        fn decode_is_copy() -> bool {
1865            false
1866        }
1867    }
1868
1869    impl fidl::encoding::ValueTypeMarker for ControlCodecStartError {
1870        type Borrowed<'a> = Self;
1871        #[inline(always)]
1872        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1873            *value
1874        }
1875    }
1876
1877    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1878        for ControlCodecStartError
1879    {
1880        #[inline]
1881        unsafe fn encode(
1882            self,
1883            encoder: &mut fidl::encoding::Encoder<'_, D>,
1884            offset: usize,
1885            _depth: fidl::encoding::Depth,
1886        ) -> fidl::Result<()> {
1887            encoder.debug_check_bounds::<Self>(offset);
1888            encoder.write_num(self.into_primitive(), offset);
1889            Ok(())
1890        }
1891    }
1892
1893    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1894        for ControlCodecStartError
1895    {
1896        #[inline(always)]
1897        fn new_empty() -> Self {
1898            Self::unknown()
1899        }
1900
1901        #[inline]
1902        unsafe fn decode(
1903            &mut self,
1904            decoder: &mut fidl::encoding::Decoder<'_, D>,
1905            offset: usize,
1906            _depth: fidl::encoding::Depth,
1907        ) -> fidl::Result<()> {
1908            decoder.debug_check_bounds::<Self>(offset);
1909            let prim = decoder.read_num::<u32>(offset);
1910
1911            *self = Self::from_primitive_allow_unknown(prim);
1912            Ok(())
1913        }
1914    }
1915    unsafe impl fidl::encoding::TypeMarker for ControlCodecStopError {
1916        type Owned = Self;
1917
1918        #[inline(always)]
1919        fn inline_align(_context: fidl::encoding::Context) -> usize {
1920            std::mem::align_of::<u32>()
1921        }
1922
1923        #[inline(always)]
1924        fn inline_size(_context: fidl::encoding::Context) -> usize {
1925            std::mem::size_of::<u32>()
1926        }
1927
1928        #[inline(always)]
1929        fn encode_is_copy() -> bool {
1930            false
1931        }
1932
1933        #[inline(always)]
1934        fn decode_is_copy() -> bool {
1935            false
1936        }
1937    }
1938
1939    impl fidl::encoding::ValueTypeMarker for ControlCodecStopError {
1940        type Borrowed<'a> = Self;
1941        #[inline(always)]
1942        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1943            *value
1944        }
1945    }
1946
1947    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1948        for ControlCodecStopError
1949    {
1950        #[inline]
1951        unsafe fn encode(
1952            self,
1953            encoder: &mut fidl::encoding::Encoder<'_, D>,
1954            offset: usize,
1955            _depth: fidl::encoding::Depth,
1956        ) -> fidl::Result<()> {
1957            encoder.debug_check_bounds::<Self>(offset);
1958            encoder.write_num(self.into_primitive(), offset);
1959            Ok(())
1960        }
1961    }
1962
1963    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlCodecStopError {
1964        #[inline(always)]
1965        fn new_empty() -> Self {
1966            Self::unknown()
1967        }
1968
1969        #[inline]
1970        unsafe fn decode(
1971            &mut self,
1972            decoder: &mut fidl::encoding::Decoder<'_, D>,
1973            offset: usize,
1974            _depth: fidl::encoding::Depth,
1975        ) -> fidl::Result<()> {
1976            decoder.debug_check_bounds::<Self>(offset);
1977            let prim = decoder.read_num::<u32>(offset);
1978
1979            *self = Self::from_primitive_allow_unknown(prim);
1980            Ok(())
1981        }
1982    }
1983    unsafe impl fidl::encoding::TypeMarker for ControlCreateRingBufferError {
1984        type Owned = Self;
1985
1986        #[inline(always)]
1987        fn inline_align(_context: fidl::encoding::Context) -> usize {
1988            std::mem::align_of::<u32>()
1989        }
1990
1991        #[inline(always)]
1992        fn inline_size(_context: fidl::encoding::Context) -> usize {
1993            std::mem::size_of::<u32>()
1994        }
1995
1996        #[inline(always)]
1997        fn encode_is_copy() -> bool {
1998            false
1999        }
2000
2001        #[inline(always)]
2002        fn decode_is_copy() -> bool {
2003            false
2004        }
2005    }
2006
2007    impl fidl::encoding::ValueTypeMarker for ControlCreateRingBufferError {
2008        type Borrowed<'a> = Self;
2009        #[inline(always)]
2010        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2011            *value
2012        }
2013    }
2014
2015    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2016        for ControlCreateRingBufferError
2017    {
2018        #[inline]
2019        unsafe fn encode(
2020            self,
2021            encoder: &mut fidl::encoding::Encoder<'_, D>,
2022            offset: usize,
2023            _depth: fidl::encoding::Depth,
2024        ) -> fidl::Result<()> {
2025            encoder.debug_check_bounds::<Self>(offset);
2026            encoder.write_num(self.into_primitive(), offset);
2027            Ok(())
2028        }
2029    }
2030
2031    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2032        for ControlCreateRingBufferError
2033    {
2034        #[inline(always)]
2035        fn new_empty() -> Self {
2036            Self::unknown()
2037        }
2038
2039        #[inline]
2040        unsafe fn decode(
2041            &mut self,
2042            decoder: &mut fidl::encoding::Decoder<'_, D>,
2043            offset: usize,
2044            _depth: fidl::encoding::Depth,
2045        ) -> fidl::Result<()> {
2046            decoder.debug_check_bounds::<Self>(offset);
2047            let prim = decoder.read_num::<u32>(offset);
2048
2049            *self = Self::from_primitive_allow_unknown(prim);
2050            Ok(())
2051        }
2052    }
2053    unsafe impl fidl::encoding::TypeMarker for ControlCreatorError {
2054        type Owned = Self;
2055
2056        #[inline(always)]
2057        fn inline_align(_context: fidl::encoding::Context) -> usize {
2058            std::mem::align_of::<u32>()
2059        }
2060
2061        #[inline(always)]
2062        fn inline_size(_context: fidl::encoding::Context) -> usize {
2063            std::mem::size_of::<u32>()
2064        }
2065
2066        #[inline(always)]
2067        fn encode_is_copy() -> bool {
2068            false
2069        }
2070
2071        #[inline(always)]
2072        fn decode_is_copy() -> bool {
2073            false
2074        }
2075    }
2076
2077    impl fidl::encoding::ValueTypeMarker for ControlCreatorError {
2078        type Borrowed<'a> = Self;
2079        #[inline(always)]
2080        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2081            *value
2082        }
2083    }
2084
2085    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2086        for ControlCreatorError
2087    {
2088        #[inline]
2089        unsafe fn encode(
2090            self,
2091            encoder: &mut fidl::encoding::Encoder<'_, D>,
2092            offset: usize,
2093            _depth: fidl::encoding::Depth,
2094        ) -> fidl::Result<()> {
2095            encoder.debug_check_bounds::<Self>(offset);
2096            encoder.write_num(self.into_primitive(), offset);
2097            Ok(())
2098        }
2099    }
2100
2101    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlCreatorError {
2102        #[inline(always)]
2103        fn new_empty() -> Self {
2104            Self::unknown()
2105        }
2106
2107        #[inline]
2108        unsafe fn decode(
2109            &mut self,
2110            decoder: &mut fidl::encoding::Decoder<'_, D>,
2111            offset: usize,
2112            _depth: fidl::encoding::Depth,
2113        ) -> fidl::Result<()> {
2114            decoder.debug_check_bounds::<Self>(offset);
2115            let prim = decoder.read_num::<u32>(offset);
2116
2117            *self = Self::from_primitive_allow_unknown(prim);
2118            Ok(())
2119        }
2120    }
2121    unsafe impl fidl::encoding::TypeMarker for ControlResetError {
2122        type Owned = Self;
2123
2124        #[inline(always)]
2125        fn inline_align(_context: fidl::encoding::Context) -> usize {
2126            std::mem::align_of::<u32>()
2127        }
2128
2129        #[inline(always)]
2130        fn inline_size(_context: fidl::encoding::Context) -> usize {
2131            std::mem::size_of::<u32>()
2132        }
2133
2134        #[inline(always)]
2135        fn encode_is_copy() -> bool {
2136            false
2137        }
2138
2139        #[inline(always)]
2140        fn decode_is_copy() -> bool {
2141            false
2142        }
2143    }
2144
2145    impl fidl::encoding::ValueTypeMarker for ControlResetError {
2146        type Borrowed<'a> = Self;
2147        #[inline(always)]
2148        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2149            *value
2150        }
2151    }
2152
2153    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2154        for ControlResetError
2155    {
2156        #[inline]
2157        unsafe fn encode(
2158            self,
2159            encoder: &mut fidl::encoding::Encoder<'_, D>,
2160            offset: usize,
2161            _depth: fidl::encoding::Depth,
2162        ) -> fidl::Result<()> {
2163            encoder.debug_check_bounds::<Self>(offset);
2164            encoder.write_num(self.into_primitive(), offset);
2165            Ok(())
2166        }
2167    }
2168
2169    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlResetError {
2170        #[inline(always)]
2171        fn new_empty() -> Self {
2172            Self::unknown()
2173        }
2174
2175        #[inline]
2176        unsafe fn decode(
2177            &mut self,
2178            decoder: &mut fidl::encoding::Decoder<'_, D>,
2179            offset: usize,
2180            _depth: fidl::encoding::Depth,
2181        ) -> fidl::Result<()> {
2182            decoder.debug_check_bounds::<Self>(offset);
2183            let prim = decoder.read_num::<u32>(offset);
2184
2185            *self = Self::from_primitive_allow_unknown(prim);
2186            Ok(())
2187        }
2188    }
2189    unsafe impl fidl::encoding::TypeMarker for ControlSetDaiFormatError {
2190        type Owned = Self;
2191
2192        #[inline(always)]
2193        fn inline_align(_context: fidl::encoding::Context) -> usize {
2194            std::mem::align_of::<u32>()
2195        }
2196
2197        #[inline(always)]
2198        fn inline_size(_context: fidl::encoding::Context) -> usize {
2199            std::mem::size_of::<u32>()
2200        }
2201
2202        #[inline(always)]
2203        fn encode_is_copy() -> bool {
2204            false
2205        }
2206
2207        #[inline(always)]
2208        fn decode_is_copy() -> bool {
2209            false
2210        }
2211    }
2212
2213    impl fidl::encoding::ValueTypeMarker for ControlSetDaiFormatError {
2214        type Borrowed<'a> = Self;
2215        #[inline(always)]
2216        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2217            *value
2218        }
2219    }
2220
2221    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2222        for ControlSetDaiFormatError
2223    {
2224        #[inline]
2225        unsafe fn encode(
2226            self,
2227            encoder: &mut fidl::encoding::Encoder<'_, D>,
2228            offset: usize,
2229            _depth: fidl::encoding::Depth,
2230        ) -> fidl::Result<()> {
2231            encoder.debug_check_bounds::<Self>(offset);
2232            encoder.write_num(self.into_primitive(), offset);
2233            Ok(())
2234        }
2235    }
2236
2237    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2238        for ControlSetDaiFormatError
2239    {
2240        #[inline(always)]
2241        fn new_empty() -> Self {
2242            Self::unknown()
2243        }
2244
2245        #[inline]
2246        unsafe fn decode(
2247            &mut self,
2248            decoder: &mut fidl::encoding::Decoder<'_, D>,
2249            offset: usize,
2250            _depth: fidl::encoding::Depth,
2251        ) -> fidl::Result<()> {
2252            decoder.debug_check_bounds::<Self>(offset);
2253            let prim = decoder.read_num::<u32>(offset);
2254
2255            *self = Self::from_primitive_allow_unknown(prim);
2256            Ok(())
2257        }
2258    }
2259    unsafe impl fidl::encoding::TypeMarker for DeviceType {
2260        type Owned = Self;
2261
2262        #[inline(always)]
2263        fn inline_align(_context: fidl::encoding::Context) -> usize {
2264            std::mem::align_of::<u32>()
2265        }
2266
2267        #[inline(always)]
2268        fn inline_size(_context: fidl::encoding::Context) -> usize {
2269            std::mem::size_of::<u32>()
2270        }
2271
2272        #[inline(always)]
2273        fn encode_is_copy() -> bool {
2274            false
2275        }
2276
2277        #[inline(always)]
2278        fn decode_is_copy() -> bool {
2279            false
2280        }
2281    }
2282
2283    impl fidl::encoding::ValueTypeMarker for DeviceType {
2284        type Borrowed<'a> = Self;
2285        #[inline(always)]
2286        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2287            *value
2288        }
2289    }
2290
2291    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for DeviceType {
2292        #[inline]
2293        unsafe fn encode(
2294            self,
2295            encoder: &mut fidl::encoding::Encoder<'_, D>,
2296            offset: usize,
2297            _depth: fidl::encoding::Depth,
2298        ) -> fidl::Result<()> {
2299            encoder.debug_check_bounds::<Self>(offset);
2300            encoder.write_num(self.into_primitive(), offset);
2301            Ok(())
2302        }
2303    }
2304
2305    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceType {
2306        #[inline(always)]
2307        fn new_empty() -> Self {
2308            Self::unknown()
2309        }
2310
2311        #[inline]
2312        unsafe fn decode(
2313            &mut self,
2314            decoder: &mut fidl::encoding::Decoder<'_, D>,
2315            offset: usize,
2316            _depth: fidl::encoding::Depth,
2317        ) -> fidl::Result<()> {
2318            decoder.debug_check_bounds::<Self>(offset);
2319            let prim = decoder.read_num::<u32>(offset);
2320
2321            *self = Self::from_primitive_allow_unknown(prim);
2322            Ok(())
2323        }
2324    }
2325    unsafe impl fidl::encoding::TypeMarker for ObserverGetReferenceClockError {
2326        type Owned = Self;
2327
2328        #[inline(always)]
2329        fn inline_align(_context: fidl::encoding::Context) -> usize {
2330            std::mem::align_of::<u32>()
2331        }
2332
2333        #[inline(always)]
2334        fn inline_size(_context: fidl::encoding::Context) -> usize {
2335            std::mem::size_of::<u32>()
2336        }
2337
2338        #[inline(always)]
2339        fn encode_is_copy() -> bool {
2340            false
2341        }
2342
2343        #[inline(always)]
2344        fn decode_is_copy() -> bool {
2345            false
2346        }
2347    }
2348
2349    impl fidl::encoding::ValueTypeMarker for ObserverGetReferenceClockError {
2350        type Borrowed<'a> = Self;
2351        #[inline(always)]
2352        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2353            *value
2354        }
2355    }
2356
2357    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2358        for ObserverGetReferenceClockError
2359    {
2360        #[inline]
2361        unsafe fn encode(
2362            self,
2363            encoder: &mut fidl::encoding::Encoder<'_, D>,
2364            offset: usize,
2365            _depth: fidl::encoding::Depth,
2366        ) -> fidl::Result<()> {
2367            encoder.debug_check_bounds::<Self>(offset);
2368            encoder.write_num(self.into_primitive(), offset);
2369            Ok(())
2370        }
2371    }
2372
2373    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2374        for ObserverGetReferenceClockError
2375    {
2376        #[inline(always)]
2377        fn new_empty() -> Self {
2378            Self::unknown()
2379        }
2380
2381        #[inline]
2382        unsafe fn decode(
2383            &mut self,
2384            decoder: &mut fidl::encoding::Decoder<'_, D>,
2385            offset: usize,
2386            _depth: fidl::encoding::Depth,
2387        ) -> fidl::Result<()> {
2388            decoder.debug_check_bounds::<Self>(offset);
2389            let prim = decoder.read_num::<u32>(offset);
2390
2391            *self = Self::from_primitive_allow_unknown(prim);
2392            Ok(())
2393        }
2394    }
2395    unsafe impl fidl::encoding::TypeMarker for ObserverWatchPlugStateError {
2396        type Owned = Self;
2397
2398        #[inline(always)]
2399        fn inline_align(_context: fidl::encoding::Context) -> usize {
2400            std::mem::align_of::<u32>()
2401        }
2402
2403        #[inline(always)]
2404        fn inline_size(_context: fidl::encoding::Context) -> usize {
2405            std::mem::size_of::<u32>()
2406        }
2407
2408        #[inline(always)]
2409        fn encode_is_copy() -> bool {
2410            false
2411        }
2412
2413        #[inline(always)]
2414        fn decode_is_copy() -> bool {
2415            false
2416        }
2417    }
2418
2419    impl fidl::encoding::ValueTypeMarker for ObserverWatchPlugStateError {
2420        type Borrowed<'a> = Self;
2421        #[inline(always)]
2422        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2423            *value
2424        }
2425    }
2426
2427    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2428        for ObserverWatchPlugStateError
2429    {
2430        #[inline]
2431        unsafe fn encode(
2432            self,
2433            encoder: &mut fidl::encoding::Encoder<'_, D>,
2434            offset: usize,
2435            _depth: fidl::encoding::Depth,
2436        ) -> fidl::Result<()> {
2437            encoder.debug_check_bounds::<Self>(offset);
2438            encoder.write_num(self.into_primitive(), offset);
2439            Ok(())
2440        }
2441    }
2442
2443    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2444        for ObserverWatchPlugStateError
2445    {
2446        #[inline(always)]
2447        fn new_empty() -> Self {
2448            Self::unknown()
2449        }
2450
2451        #[inline]
2452        unsafe fn decode(
2453            &mut self,
2454            decoder: &mut fidl::encoding::Decoder<'_, D>,
2455            offset: usize,
2456            _depth: fidl::encoding::Depth,
2457        ) -> fidl::Result<()> {
2458            decoder.debug_check_bounds::<Self>(offset);
2459            let prim = decoder.read_num::<u32>(offset);
2460
2461            *self = Self::from_primitive_allow_unknown(prim);
2462            Ok(())
2463        }
2464    }
2465    unsafe impl fidl::encoding::TypeMarker for PlugDetectCapabilities {
2466        type Owned = Self;
2467
2468        #[inline(always)]
2469        fn inline_align(_context: fidl::encoding::Context) -> usize {
2470            std::mem::align_of::<u32>()
2471        }
2472
2473        #[inline(always)]
2474        fn inline_size(_context: fidl::encoding::Context) -> usize {
2475            std::mem::size_of::<u32>()
2476        }
2477
2478        #[inline(always)]
2479        fn encode_is_copy() -> bool {
2480            false
2481        }
2482
2483        #[inline(always)]
2484        fn decode_is_copy() -> bool {
2485            false
2486        }
2487    }
2488
2489    impl fidl::encoding::ValueTypeMarker for PlugDetectCapabilities {
2490        type Borrowed<'a> = Self;
2491        #[inline(always)]
2492        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2493            *value
2494        }
2495    }
2496
2497    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2498        for PlugDetectCapabilities
2499    {
2500        #[inline]
2501        unsafe fn encode(
2502            self,
2503            encoder: &mut fidl::encoding::Encoder<'_, D>,
2504            offset: usize,
2505            _depth: fidl::encoding::Depth,
2506        ) -> fidl::Result<()> {
2507            encoder.debug_check_bounds::<Self>(offset);
2508            encoder.write_num(self.into_primitive(), offset);
2509            Ok(())
2510        }
2511    }
2512
2513    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2514        for PlugDetectCapabilities
2515    {
2516        #[inline(always)]
2517        fn new_empty() -> Self {
2518            Self::unknown()
2519        }
2520
2521        #[inline]
2522        unsafe fn decode(
2523            &mut self,
2524            decoder: &mut fidl::encoding::Decoder<'_, D>,
2525            offset: usize,
2526            _depth: fidl::encoding::Depth,
2527        ) -> fidl::Result<()> {
2528            decoder.debug_check_bounds::<Self>(offset);
2529            let prim = decoder.read_num::<u32>(offset);
2530
2531            *self = Self::from_primitive_allow_unknown(prim);
2532            Ok(())
2533        }
2534    }
2535    unsafe impl fidl::encoding::TypeMarker for PlugState {
2536        type Owned = Self;
2537
2538        #[inline(always)]
2539        fn inline_align(_context: fidl::encoding::Context) -> usize {
2540            std::mem::align_of::<u32>()
2541        }
2542
2543        #[inline(always)]
2544        fn inline_size(_context: fidl::encoding::Context) -> usize {
2545            std::mem::size_of::<u32>()
2546        }
2547
2548        #[inline(always)]
2549        fn encode_is_copy() -> bool {
2550            false
2551        }
2552
2553        #[inline(always)]
2554        fn decode_is_copy() -> bool {
2555            false
2556        }
2557    }
2558
2559    impl fidl::encoding::ValueTypeMarker for PlugState {
2560        type Borrowed<'a> = Self;
2561        #[inline(always)]
2562        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2563            *value
2564        }
2565    }
2566
2567    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for PlugState {
2568        #[inline]
2569        unsafe fn encode(
2570            self,
2571            encoder: &mut fidl::encoding::Encoder<'_, D>,
2572            offset: usize,
2573            _depth: fidl::encoding::Depth,
2574        ) -> fidl::Result<()> {
2575            encoder.debug_check_bounds::<Self>(offset);
2576            encoder.write_num(self.into_primitive(), offset);
2577            Ok(())
2578        }
2579    }
2580
2581    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PlugState {
2582        #[inline(always)]
2583        fn new_empty() -> Self {
2584            Self::unknown()
2585        }
2586
2587        #[inline]
2588        unsafe fn decode(
2589            &mut self,
2590            decoder: &mut fidl::encoding::Decoder<'_, D>,
2591            offset: usize,
2592            _depth: fidl::encoding::Depth,
2593        ) -> fidl::Result<()> {
2594            decoder.debug_check_bounds::<Self>(offset);
2595            let prim = decoder.read_num::<u32>(offset);
2596
2597            *self = Self::from_primitive_allow_unknown(prim);
2598            Ok(())
2599        }
2600    }
2601    unsafe impl fidl::encoding::TypeMarker for ProviderAddDeviceError {
2602        type Owned = Self;
2603
2604        #[inline(always)]
2605        fn inline_align(_context: fidl::encoding::Context) -> usize {
2606            std::mem::align_of::<u32>()
2607        }
2608
2609        #[inline(always)]
2610        fn inline_size(_context: fidl::encoding::Context) -> usize {
2611            std::mem::size_of::<u32>()
2612        }
2613
2614        #[inline(always)]
2615        fn encode_is_copy() -> bool {
2616            false
2617        }
2618
2619        #[inline(always)]
2620        fn decode_is_copy() -> bool {
2621            false
2622        }
2623    }
2624
2625    impl fidl::encoding::ValueTypeMarker for ProviderAddDeviceError {
2626        type Borrowed<'a> = Self;
2627        #[inline(always)]
2628        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2629            *value
2630        }
2631    }
2632
2633    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2634        for ProviderAddDeviceError
2635    {
2636        #[inline]
2637        unsafe fn encode(
2638            self,
2639            encoder: &mut fidl::encoding::Encoder<'_, D>,
2640            offset: usize,
2641            _depth: fidl::encoding::Depth,
2642        ) -> fidl::Result<()> {
2643            encoder.debug_check_bounds::<Self>(offset);
2644            encoder.write_num(self.into_primitive(), offset);
2645            Ok(())
2646        }
2647    }
2648
2649    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2650        for ProviderAddDeviceError
2651    {
2652        #[inline(always)]
2653        fn new_empty() -> Self {
2654            Self::unknown()
2655        }
2656
2657        #[inline]
2658        unsafe fn decode(
2659            &mut self,
2660            decoder: &mut fidl::encoding::Decoder<'_, D>,
2661            offset: usize,
2662            _depth: fidl::encoding::Depth,
2663        ) -> fidl::Result<()> {
2664            decoder.debug_check_bounds::<Self>(offset);
2665            let prim = decoder.read_num::<u32>(offset);
2666
2667            *self = Self::from_primitive_allow_unknown(prim);
2668            Ok(())
2669        }
2670    }
2671    unsafe impl fidl::encoding::TypeMarker for RegistryCreateObserverError {
2672        type Owned = Self;
2673
2674        #[inline(always)]
2675        fn inline_align(_context: fidl::encoding::Context) -> usize {
2676            std::mem::align_of::<u32>()
2677        }
2678
2679        #[inline(always)]
2680        fn inline_size(_context: fidl::encoding::Context) -> usize {
2681            std::mem::size_of::<u32>()
2682        }
2683
2684        #[inline(always)]
2685        fn encode_is_copy() -> bool {
2686            false
2687        }
2688
2689        #[inline(always)]
2690        fn decode_is_copy() -> bool {
2691            false
2692        }
2693    }
2694
2695    impl fidl::encoding::ValueTypeMarker for RegistryCreateObserverError {
2696        type Borrowed<'a> = Self;
2697        #[inline(always)]
2698        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2699            *value
2700        }
2701    }
2702
2703    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2704        for RegistryCreateObserverError
2705    {
2706        #[inline]
2707        unsafe fn encode(
2708            self,
2709            encoder: &mut fidl::encoding::Encoder<'_, D>,
2710            offset: usize,
2711            _depth: fidl::encoding::Depth,
2712        ) -> fidl::Result<()> {
2713            encoder.debug_check_bounds::<Self>(offset);
2714            encoder.write_num(self.into_primitive(), offset);
2715            Ok(())
2716        }
2717    }
2718
2719    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2720        for RegistryCreateObserverError
2721    {
2722        #[inline(always)]
2723        fn new_empty() -> Self {
2724            Self::unknown()
2725        }
2726
2727        #[inline]
2728        unsafe fn decode(
2729            &mut self,
2730            decoder: &mut fidl::encoding::Decoder<'_, D>,
2731            offset: usize,
2732            _depth: fidl::encoding::Depth,
2733        ) -> fidl::Result<()> {
2734            decoder.debug_check_bounds::<Self>(offset);
2735            let prim = decoder.read_num::<u32>(offset);
2736
2737            *self = Self::from_primitive_allow_unknown(prim);
2738            Ok(())
2739        }
2740    }
2741    unsafe impl fidl::encoding::TypeMarker for RegistryWatchDeviceRemovedError {
2742        type Owned = Self;
2743
2744        #[inline(always)]
2745        fn inline_align(_context: fidl::encoding::Context) -> usize {
2746            std::mem::align_of::<u32>()
2747        }
2748
2749        #[inline(always)]
2750        fn inline_size(_context: fidl::encoding::Context) -> usize {
2751            std::mem::size_of::<u32>()
2752        }
2753
2754        #[inline(always)]
2755        fn encode_is_copy() -> bool {
2756            false
2757        }
2758
2759        #[inline(always)]
2760        fn decode_is_copy() -> bool {
2761            false
2762        }
2763    }
2764
2765    impl fidl::encoding::ValueTypeMarker for RegistryWatchDeviceRemovedError {
2766        type Borrowed<'a> = Self;
2767        #[inline(always)]
2768        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2769            *value
2770        }
2771    }
2772
2773    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2774        for RegistryWatchDeviceRemovedError
2775    {
2776        #[inline]
2777        unsafe fn encode(
2778            self,
2779            encoder: &mut fidl::encoding::Encoder<'_, D>,
2780            offset: usize,
2781            _depth: fidl::encoding::Depth,
2782        ) -> fidl::Result<()> {
2783            encoder.debug_check_bounds::<Self>(offset);
2784            encoder.write_num(self.into_primitive(), offset);
2785            Ok(())
2786        }
2787    }
2788
2789    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2790        for RegistryWatchDeviceRemovedError
2791    {
2792        #[inline(always)]
2793        fn new_empty() -> Self {
2794            Self::unknown()
2795        }
2796
2797        #[inline]
2798        unsafe fn decode(
2799            &mut self,
2800            decoder: &mut fidl::encoding::Decoder<'_, D>,
2801            offset: usize,
2802            _depth: fidl::encoding::Depth,
2803        ) -> fidl::Result<()> {
2804            decoder.debug_check_bounds::<Self>(offset);
2805            let prim = decoder.read_num::<u32>(offset);
2806
2807            *self = Self::from_primitive_allow_unknown(prim);
2808            Ok(())
2809        }
2810    }
2811    unsafe impl fidl::encoding::TypeMarker for RegistryWatchDevicesAddedError {
2812        type Owned = Self;
2813
2814        #[inline(always)]
2815        fn inline_align(_context: fidl::encoding::Context) -> usize {
2816            std::mem::align_of::<u32>()
2817        }
2818
2819        #[inline(always)]
2820        fn inline_size(_context: fidl::encoding::Context) -> usize {
2821            std::mem::size_of::<u32>()
2822        }
2823
2824        #[inline(always)]
2825        fn encode_is_copy() -> bool {
2826            false
2827        }
2828
2829        #[inline(always)]
2830        fn decode_is_copy() -> bool {
2831            false
2832        }
2833    }
2834
2835    impl fidl::encoding::ValueTypeMarker for RegistryWatchDevicesAddedError {
2836        type Borrowed<'a> = Self;
2837        #[inline(always)]
2838        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2839            *value
2840        }
2841    }
2842
2843    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2844        for RegistryWatchDevicesAddedError
2845    {
2846        #[inline]
2847        unsafe fn encode(
2848            self,
2849            encoder: &mut fidl::encoding::Encoder<'_, D>,
2850            offset: usize,
2851            _depth: fidl::encoding::Depth,
2852        ) -> fidl::Result<()> {
2853            encoder.debug_check_bounds::<Self>(offset);
2854            encoder.write_num(self.into_primitive(), offset);
2855            Ok(())
2856        }
2857    }
2858
2859    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2860        for RegistryWatchDevicesAddedError
2861    {
2862        #[inline(always)]
2863        fn new_empty() -> Self {
2864            Self::unknown()
2865        }
2866
2867        #[inline]
2868        unsafe fn decode(
2869            &mut self,
2870            decoder: &mut fidl::encoding::Decoder<'_, D>,
2871            offset: usize,
2872            _depth: fidl::encoding::Depth,
2873        ) -> fidl::Result<()> {
2874            decoder.debug_check_bounds::<Self>(offset);
2875            let prim = decoder.read_num::<u32>(offset);
2876
2877            *self = Self::from_primitive_allow_unknown(prim);
2878            Ok(())
2879        }
2880    }
2881    unsafe impl fidl::encoding::TypeMarker for RingBufferSetActiveChannelsError {
2882        type Owned = Self;
2883
2884        #[inline(always)]
2885        fn inline_align(_context: fidl::encoding::Context) -> usize {
2886            std::mem::align_of::<u32>()
2887        }
2888
2889        #[inline(always)]
2890        fn inline_size(_context: fidl::encoding::Context) -> usize {
2891            std::mem::size_of::<u32>()
2892        }
2893
2894        #[inline(always)]
2895        fn encode_is_copy() -> bool {
2896            false
2897        }
2898
2899        #[inline(always)]
2900        fn decode_is_copy() -> bool {
2901            false
2902        }
2903    }
2904
2905    impl fidl::encoding::ValueTypeMarker for RingBufferSetActiveChannelsError {
2906        type Borrowed<'a> = Self;
2907        #[inline(always)]
2908        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2909            *value
2910        }
2911    }
2912
2913    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2914        for RingBufferSetActiveChannelsError
2915    {
2916        #[inline]
2917        unsafe fn encode(
2918            self,
2919            encoder: &mut fidl::encoding::Encoder<'_, D>,
2920            offset: usize,
2921            _depth: fidl::encoding::Depth,
2922        ) -> fidl::Result<()> {
2923            encoder.debug_check_bounds::<Self>(offset);
2924            encoder.write_num(self.into_primitive(), offset);
2925            Ok(())
2926        }
2927    }
2928
2929    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2930        for RingBufferSetActiveChannelsError
2931    {
2932        #[inline(always)]
2933        fn new_empty() -> Self {
2934            Self::unknown()
2935        }
2936
2937        #[inline]
2938        unsafe fn decode(
2939            &mut self,
2940            decoder: &mut fidl::encoding::Decoder<'_, D>,
2941            offset: usize,
2942            _depth: fidl::encoding::Depth,
2943        ) -> fidl::Result<()> {
2944            decoder.debug_check_bounds::<Self>(offset);
2945            let prim = decoder.read_num::<u32>(offset);
2946
2947            *self = Self::from_primitive_allow_unknown(prim);
2948            Ok(())
2949        }
2950    }
2951    unsafe impl fidl::encoding::TypeMarker for RingBufferStartError {
2952        type Owned = Self;
2953
2954        #[inline(always)]
2955        fn inline_align(_context: fidl::encoding::Context) -> usize {
2956            std::mem::align_of::<u32>()
2957        }
2958
2959        #[inline(always)]
2960        fn inline_size(_context: fidl::encoding::Context) -> usize {
2961            std::mem::size_of::<u32>()
2962        }
2963
2964        #[inline(always)]
2965        fn encode_is_copy() -> bool {
2966            false
2967        }
2968
2969        #[inline(always)]
2970        fn decode_is_copy() -> bool {
2971            false
2972        }
2973    }
2974
2975    impl fidl::encoding::ValueTypeMarker for RingBufferStartError {
2976        type Borrowed<'a> = Self;
2977        #[inline(always)]
2978        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2979            *value
2980        }
2981    }
2982
2983    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
2984        for RingBufferStartError
2985    {
2986        #[inline]
2987        unsafe fn encode(
2988            self,
2989            encoder: &mut fidl::encoding::Encoder<'_, D>,
2990            offset: usize,
2991            _depth: fidl::encoding::Depth,
2992        ) -> fidl::Result<()> {
2993            encoder.debug_check_bounds::<Self>(offset);
2994            encoder.write_num(self.into_primitive(), offset);
2995            Ok(())
2996        }
2997    }
2998
2999    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferStartError {
3000        #[inline(always)]
3001        fn new_empty() -> Self {
3002            Self::unknown()
3003        }
3004
3005        #[inline]
3006        unsafe fn decode(
3007            &mut self,
3008            decoder: &mut fidl::encoding::Decoder<'_, D>,
3009            offset: usize,
3010            _depth: fidl::encoding::Depth,
3011        ) -> fidl::Result<()> {
3012            decoder.debug_check_bounds::<Self>(offset);
3013            let prim = decoder.read_num::<u32>(offset);
3014
3015            *self = Self::from_primitive_allow_unknown(prim);
3016            Ok(())
3017        }
3018    }
3019    unsafe impl fidl::encoding::TypeMarker for RingBufferStopError {
3020        type Owned = Self;
3021
3022        #[inline(always)]
3023        fn inline_align(_context: fidl::encoding::Context) -> usize {
3024            std::mem::align_of::<u32>()
3025        }
3026
3027        #[inline(always)]
3028        fn inline_size(_context: fidl::encoding::Context) -> usize {
3029            std::mem::size_of::<u32>()
3030        }
3031
3032        #[inline(always)]
3033        fn encode_is_copy() -> bool {
3034            false
3035        }
3036
3037        #[inline(always)]
3038        fn decode_is_copy() -> bool {
3039            false
3040        }
3041    }
3042
3043    impl fidl::encoding::ValueTypeMarker for RingBufferStopError {
3044        type Borrowed<'a> = Self;
3045        #[inline(always)]
3046        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3047            *value
3048        }
3049    }
3050
3051    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3052        for RingBufferStopError
3053    {
3054        #[inline]
3055        unsafe fn encode(
3056            self,
3057            encoder: &mut fidl::encoding::Encoder<'_, D>,
3058            offset: usize,
3059            _depth: fidl::encoding::Depth,
3060        ) -> fidl::Result<()> {
3061            encoder.debug_check_bounds::<Self>(offset);
3062            encoder.write_num(self.into_primitive(), offset);
3063            Ok(())
3064        }
3065    }
3066
3067    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferStopError {
3068        #[inline(always)]
3069        fn new_empty() -> Self {
3070            Self::unknown()
3071        }
3072
3073        #[inline]
3074        unsafe fn decode(
3075            &mut self,
3076            decoder: &mut fidl::encoding::Decoder<'_, D>,
3077            offset: usize,
3078            _depth: fidl::encoding::Depth,
3079        ) -> fidl::Result<()> {
3080            decoder.debug_check_bounds::<Self>(offset);
3081            let prim = decoder.read_num::<u32>(offset);
3082
3083            *self = Self::from_primitive_allow_unknown(prim);
3084            Ok(())
3085        }
3086    }
3087    unsafe impl fidl::encoding::TypeMarker for RingBufferWatchDelayInfoError {
3088        type Owned = Self;
3089
3090        #[inline(always)]
3091        fn inline_align(_context: fidl::encoding::Context) -> usize {
3092            std::mem::align_of::<u32>()
3093        }
3094
3095        #[inline(always)]
3096        fn inline_size(_context: fidl::encoding::Context) -> usize {
3097            std::mem::size_of::<u32>()
3098        }
3099
3100        #[inline(always)]
3101        fn encode_is_copy() -> bool {
3102            false
3103        }
3104
3105        #[inline(always)]
3106        fn decode_is_copy() -> bool {
3107            false
3108        }
3109    }
3110
3111    impl fidl::encoding::ValueTypeMarker for RingBufferWatchDelayInfoError {
3112        type Borrowed<'a> = Self;
3113        #[inline(always)]
3114        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3115            *value
3116        }
3117    }
3118
3119    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
3120        for RingBufferWatchDelayInfoError
3121    {
3122        #[inline]
3123        unsafe fn encode(
3124            self,
3125            encoder: &mut fidl::encoding::Encoder<'_, D>,
3126            offset: usize,
3127            _depth: fidl::encoding::Depth,
3128        ) -> fidl::Result<()> {
3129            encoder.debug_check_bounds::<Self>(offset);
3130            encoder.write_num(self.into_primitive(), offset);
3131            Ok(())
3132        }
3133    }
3134
3135    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3136        for RingBufferWatchDelayInfoError
3137    {
3138        #[inline(always)]
3139        fn new_empty() -> Self {
3140            Self::unknown()
3141        }
3142
3143        #[inline]
3144        unsafe fn decode(
3145            &mut self,
3146            decoder: &mut fidl::encoding::Decoder<'_, D>,
3147            offset: usize,
3148            _depth: fidl::encoding::Depth,
3149        ) -> fidl::Result<()> {
3150            decoder.debug_check_bounds::<Self>(offset);
3151            let prim = decoder.read_num::<u32>(offset);
3152
3153            *self = Self::from_primitive_allow_unknown(prim);
3154            Ok(())
3155        }
3156    }
3157
3158    impl ChannelAttributes {
3159        #[inline(always)]
3160        fn max_ordinal_present(&self) -> u64 {
3161            if let Some(_) = self.max_frequency {
3162                return 2;
3163            }
3164            if let Some(_) = self.min_frequency {
3165                return 1;
3166            }
3167            0
3168        }
3169    }
3170
3171    impl fidl::encoding::ValueTypeMarker for ChannelAttributes {
3172        type Borrowed<'a> = &'a Self;
3173        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3174            value
3175        }
3176    }
3177
3178    unsafe impl fidl::encoding::TypeMarker for ChannelAttributes {
3179        type Owned = Self;
3180
3181        #[inline(always)]
3182        fn inline_align(_context: fidl::encoding::Context) -> usize {
3183            8
3184        }
3185
3186        #[inline(always)]
3187        fn inline_size(_context: fidl::encoding::Context) -> usize {
3188            16
3189        }
3190    }
3191
3192    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChannelAttributes, D>
3193        for &ChannelAttributes
3194    {
3195        unsafe fn encode(
3196            self,
3197            encoder: &mut fidl::encoding::Encoder<'_, D>,
3198            offset: usize,
3199            mut depth: fidl::encoding::Depth,
3200        ) -> fidl::Result<()> {
3201            encoder.debug_check_bounds::<ChannelAttributes>(offset);
3202            // Vector header
3203            let max_ordinal: u64 = self.max_ordinal_present();
3204            encoder.write_num(max_ordinal, offset);
3205            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3206            // Calling encoder.out_of_line_offset(0) is not allowed.
3207            if max_ordinal == 0 {
3208                return Ok(());
3209            }
3210            depth.increment()?;
3211            let envelope_size = 8;
3212            let bytes_len = max_ordinal as usize * envelope_size;
3213            #[allow(unused_variables)]
3214            let offset = encoder.out_of_line_offset(bytes_len);
3215            let mut _prev_end_offset: usize = 0;
3216            if 1 > max_ordinal {
3217                return Ok(());
3218            }
3219
3220            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3221            // are envelope_size bytes.
3222            let cur_offset: usize = (1 - 1) * envelope_size;
3223
3224            // Zero reserved fields.
3225            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3226
3227            // Safety:
3228            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3229            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3230            //   envelope_size bytes, there is always sufficient room.
3231            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3232                self.min_frequency.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3233                encoder,
3234                offset + cur_offset,
3235                depth,
3236            )?;
3237
3238            _prev_end_offset = cur_offset + envelope_size;
3239            if 2 > max_ordinal {
3240                return Ok(());
3241            }
3242
3243            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3244            // are envelope_size bytes.
3245            let cur_offset: usize = (2 - 1) * envelope_size;
3246
3247            // Zero reserved fields.
3248            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3249
3250            // Safety:
3251            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3252            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3253            //   envelope_size bytes, there is always sufficient room.
3254            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3255                self.max_frequency.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3256                encoder,
3257                offset + cur_offset,
3258                depth,
3259            )?;
3260
3261            _prev_end_offset = cur_offset + envelope_size;
3262
3263            Ok(())
3264        }
3265    }
3266
3267    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChannelAttributes {
3268        #[inline(always)]
3269        fn new_empty() -> Self {
3270            Self::default()
3271        }
3272
3273        unsafe fn decode(
3274            &mut self,
3275            decoder: &mut fidl::encoding::Decoder<'_, D>,
3276            offset: usize,
3277            mut depth: fidl::encoding::Depth,
3278        ) -> fidl::Result<()> {
3279            decoder.debug_check_bounds::<Self>(offset);
3280            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3281                None => return Err(fidl::Error::NotNullable),
3282                Some(len) => len,
3283            };
3284            // Calling decoder.out_of_line_offset(0) is not allowed.
3285            if len == 0 {
3286                return Ok(());
3287            };
3288            depth.increment()?;
3289            let envelope_size = 8;
3290            let bytes_len = len * envelope_size;
3291            let offset = decoder.out_of_line_offset(bytes_len)?;
3292            // Decode the envelope for each type.
3293            let mut _next_ordinal_to_read = 0;
3294            let mut next_offset = offset;
3295            let end_offset = offset + bytes_len;
3296            _next_ordinal_to_read += 1;
3297            if next_offset >= end_offset {
3298                return Ok(());
3299            }
3300
3301            // Decode unknown envelopes for gaps in ordinals.
3302            while _next_ordinal_to_read < 1 {
3303                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3304                _next_ordinal_to_read += 1;
3305                next_offset += envelope_size;
3306            }
3307
3308            let next_out_of_line = decoder.next_out_of_line();
3309            let handles_before = decoder.remaining_handles();
3310            if let Some((inlined, num_bytes, num_handles)) =
3311                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3312            {
3313                let member_inline_size =
3314                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3315                if inlined != (member_inline_size <= 4) {
3316                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3317                }
3318                let inner_offset;
3319                let mut inner_depth = depth.clone();
3320                if inlined {
3321                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3322                    inner_offset = next_offset;
3323                } else {
3324                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3325                    inner_depth.increment()?;
3326                }
3327                let val_ref = self.min_frequency.get_or_insert_with(|| fidl::new_empty!(u32, D));
3328                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3329                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3330                {
3331                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3332                }
3333                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3334                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3335                }
3336            }
3337
3338            next_offset += envelope_size;
3339            _next_ordinal_to_read += 1;
3340            if next_offset >= end_offset {
3341                return Ok(());
3342            }
3343
3344            // Decode unknown envelopes for gaps in ordinals.
3345            while _next_ordinal_to_read < 2 {
3346                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3347                _next_ordinal_to_read += 1;
3348                next_offset += envelope_size;
3349            }
3350
3351            let next_out_of_line = decoder.next_out_of_line();
3352            let handles_before = decoder.remaining_handles();
3353            if let Some((inlined, num_bytes, num_handles)) =
3354                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3355            {
3356                let member_inline_size =
3357                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3358                if inlined != (member_inline_size <= 4) {
3359                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3360                }
3361                let inner_offset;
3362                let mut inner_depth = depth.clone();
3363                if inlined {
3364                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3365                    inner_offset = next_offset;
3366                } else {
3367                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3368                    inner_depth.increment()?;
3369                }
3370                let val_ref = self.max_frequency.get_or_insert_with(|| fidl::new_empty!(u32, D));
3371                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3372                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3373                {
3374                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3375                }
3376                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3377                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3378                }
3379            }
3380
3381            next_offset += envelope_size;
3382
3383            // Decode the remaining unknown envelopes.
3384            while next_offset < end_offset {
3385                _next_ordinal_to_read += 1;
3386                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3387                next_offset += envelope_size;
3388            }
3389
3390            Ok(())
3391        }
3392    }
3393
3394    impl ChannelSet {
3395        #[inline(always)]
3396        fn max_ordinal_present(&self) -> u64 {
3397            if let Some(_) = self.attributes {
3398                return 1;
3399            }
3400            0
3401        }
3402    }
3403
3404    impl fidl::encoding::ValueTypeMarker for ChannelSet {
3405        type Borrowed<'a> = &'a Self;
3406        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3407            value
3408        }
3409    }
3410
3411    unsafe impl fidl::encoding::TypeMarker for ChannelSet {
3412        type Owned = Self;
3413
3414        #[inline(always)]
3415        fn inline_align(_context: fidl::encoding::Context) -> usize {
3416            8
3417        }
3418
3419        #[inline(always)]
3420        fn inline_size(_context: fidl::encoding::Context) -> usize {
3421            16
3422        }
3423    }
3424
3425    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChannelSet, D>
3426        for &ChannelSet
3427    {
3428        unsafe fn encode(
3429            self,
3430            encoder: &mut fidl::encoding::Encoder<'_, D>,
3431            offset: usize,
3432            mut depth: fidl::encoding::Depth,
3433        ) -> fidl::Result<()> {
3434            encoder.debug_check_bounds::<ChannelSet>(offset);
3435            // Vector header
3436            let max_ordinal: u64 = self.max_ordinal_present();
3437            encoder.write_num(max_ordinal, offset);
3438            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3439            // Calling encoder.out_of_line_offset(0) is not allowed.
3440            if max_ordinal == 0 {
3441                return Ok(());
3442            }
3443            depth.increment()?;
3444            let envelope_size = 8;
3445            let bytes_len = max_ordinal as usize * envelope_size;
3446            #[allow(unused_variables)]
3447            let offset = encoder.out_of_line_offset(bytes_len);
3448            let mut _prev_end_offset: usize = 0;
3449            if 1 > max_ordinal {
3450                return Ok(());
3451            }
3452
3453            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3454            // are envelope_size bytes.
3455            let cur_offset: usize = (1 - 1) * envelope_size;
3456
3457            // Zero reserved fields.
3458            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3459
3460            // Safety:
3461            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3462            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3463            //   envelope_size bytes, there is always sufficient room.
3464            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ChannelAttributes, 64>, D>(
3465            self.attributes.as_ref().map(<fidl::encoding::Vector<ChannelAttributes, 64> as fidl::encoding::ValueTypeMarker>::borrow),
3466            encoder, offset + cur_offset, depth
3467        )?;
3468
3469            _prev_end_offset = cur_offset + envelope_size;
3470
3471            Ok(())
3472        }
3473    }
3474
3475    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChannelSet {
3476        #[inline(always)]
3477        fn new_empty() -> Self {
3478            Self::default()
3479        }
3480
3481        unsafe fn decode(
3482            &mut self,
3483            decoder: &mut fidl::encoding::Decoder<'_, D>,
3484            offset: usize,
3485            mut depth: fidl::encoding::Depth,
3486        ) -> fidl::Result<()> {
3487            decoder.debug_check_bounds::<Self>(offset);
3488            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3489                None => return Err(fidl::Error::NotNullable),
3490                Some(len) => len,
3491            };
3492            // Calling decoder.out_of_line_offset(0) is not allowed.
3493            if len == 0 {
3494                return Ok(());
3495            };
3496            depth.increment()?;
3497            let envelope_size = 8;
3498            let bytes_len = len * envelope_size;
3499            let offset = decoder.out_of_line_offset(bytes_len)?;
3500            // Decode the envelope for each type.
3501            let mut _next_ordinal_to_read = 0;
3502            let mut next_offset = offset;
3503            let end_offset = offset + bytes_len;
3504            _next_ordinal_to_read += 1;
3505            if next_offset >= end_offset {
3506                return Ok(());
3507            }
3508
3509            // Decode unknown envelopes for gaps in ordinals.
3510            while _next_ordinal_to_read < 1 {
3511                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3512                _next_ordinal_to_read += 1;
3513                next_offset += envelope_size;
3514            }
3515
3516            let next_out_of_line = decoder.next_out_of_line();
3517            let handles_before = decoder.remaining_handles();
3518            if let Some((inlined, num_bytes, num_handles)) =
3519                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3520            {
3521                let member_inline_size = <fidl::encoding::Vector<ChannelAttributes, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3522                if inlined != (member_inline_size <= 4) {
3523                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3524                }
3525                let inner_offset;
3526                let mut inner_depth = depth.clone();
3527                if inlined {
3528                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3529                    inner_offset = next_offset;
3530                } else {
3531                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3532                    inner_depth.increment()?;
3533                }
3534                let val_ref = self.attributes.get_or_insert_with(
3535                    || fidl::new_empty!(fidl::encoding::Vector<ChannelAttributes, 64>, D),
3536                );
3537                fidl::decode!(fidl::encoding::Vector<ChannelAttributes, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
3538                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3539                {
3540                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3541                }
3542                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3543                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3544                }
3545            }
3546
3547            next_offset += envelope_size;
3548
3549            // Decode the remaining unknown envelopes.
3550            while next_offset < end_offset {
3551                _next_ordinal_to_read += 1;
3552                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3553                next_offset += envelope_size;
3554            }
3555
3556            Ok(())
3557        }
3558    }
3559
3560    impl ControlCreatorCreateResponse {
3561        #[inline(always)]
3562        fn max_ordinal_present(&self) -> u64 {
3563            0
3564        }
3565    }
3566
3567    impl fidl::encoding::ValueTypeMarker for ControlCreatorCreateResponse {
3568        type Borrowed<'a> = &'a Self;
3569        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3570            value
3571        }
3572    }
3573
3574    unsafe impl fidl::encoding::TypeMarker for ControlCreatorCreateResponse {
3575        type Owned = Self;
3576
3577        #[inline(always)]
3578        fn inline_align(_context: fidl::encoding::Context) -> usize {
3579            8
3580        }
3581
3582        #[inline(always)]
3583        fn inline_size(_context: fidl::encoding::Context) -> usize {
3584            16
3585        }
3586    }
3587
3588    unsafe impl<D: fidl::encoding::ResourceDialect>
3589        fidl::encoding::Encode<ControlCreatorCreateResponse, D> for &ControlCreatorCreateResponse
3590    {
3591        unsafe fn encode(
3592            self,
3593            encoder: &mut fidl::encoding::Encoder<'_, D>,
3594            offset: usize,
3595            mut depth: fidl::encoding::Depth,
3596        ) -> fidl::Result<()> {
3597            encoder.debug_check_bounds::<ControlCreatorCreateResponse>(offset);
3598            // Vector header
3599            let max_ordinal: u64 = self.max_ordinal_present();
3600            encoder.write_num(max_ordinal, offset);
3601            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3602            // Calling encoder.out_of_line_offset(0) is not allowed.
3603            if max_ordinal == 0 {
3604                return Ok(());
3605            }
3606            depth.increment()?;
3607            let envelope_size = 8;
3608            let bytes_len = max_ordinal as usize * envelope_size;
3609            #[allow(unused_variables)]
3610            let offset = encoder.out_of_line_offset(bytes_len);
3611            let mut _prev_end_offset: usize = 0;
3612
3613            Ok(())
3614        }
3615    }
3616
3617    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3618        for ControlCreatorCreateResponse
3619    {
3620        #[inline(always)]
3621        fn new_empty() -> Self {
3622            Self::default()
3623        }
3624
3625        unsafe fn decode(
3626            &mut self,
3627            decoder: &mut fidl::encoding::Decoder<'_, D>,
3628            offset: usize,
3629            mut depth: fidl::encoding::Depth,
3630        ) -> fidl::Result<()> {
3631            decoder.debug_check_bounds::<Self>(offset);
3632            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3633                None => return Err(fidl::Error::NotNullable),
3634                Some(len) => len,
3635            };
3636            // Calling decoder.out_of_line_offset(0) is not allowed.
3637            if len == 0 {
3638                return Ok(());
3639            };
3640            depth.increment()?;
3641            let envelope_size = 8;
3642            let bytes_len = len * envelope_size;
3643            let offset = decoder.out_of_line_offset(bytes_len)?;
3644            // Decode the envelope for each type.
3645            let mut _next_ordinal_to_read = 0;
3646            let mut next_offset = offset;
3647            let end_offset = offset + bytes_len;
3648
3649            // Decode the remaining unknown envelopes.
3650            while next_offset < end_offset {
3651                _next_ordinal_to_read += 1;
3652                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3653                next_offset += envelope_size;
3654            }
3655
3656            Ok(())
3657        }
3658    }
3659
3660    impl ControlSetDaiFormatRequest {
3661        #[inline(always)]
3662        fn max_ordinal_present(&self) -> u64 {
3663            if let Some(_) = self.dai_format {
3664                return 2;
3665            }
3666            if let Some(_) = self.element_id {
3667                return 1;
3668            }
3669            0
3670        }
3671    }
3672
3673    impl fidl::encoding::ValueTypeMarker for ControlSetDaiFormatRequest {
3674        type Borrowed<'a> = &'a Self;
3675        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3676            value
3677        }
3678    }
3679
3680    unsafe impl fidl::encoding::TypeMarker for ControlSetDaiFormatRequest {
3681        type Owned = Self;
3682
3683        #[inline(always)]
3684        fn inline_align(_context: fidl::encoding::Context) -> usize {
3685            8
3686        }
3687
3688        #[inline(always)]
3689        fn inline_size(_context: fidl::encoding::Context) -> usize {
3690            16
3691        }
3692    }
3693
3694    unsafe impl<D: fidl::encoding::ResourceDialect>
3695        fidl::encoding::Encode<ControlSetDaiFormatRequest, D> for &ControlSetDaiFormatRequest
3696    {
3697        unsafe fn encode(
3698            self,
3699            encoder: &mut fidl::encoding::Encoder<'_, D>,
3700            offset: usize,
3701            mut depth: fidl::encoding::Depth,
3702        ) -> fidl::Result<()> {
3703            encoder.debug_check_bounds::<ControlSetDaiFormatRequest>(offset);
3704            // Vector header
3705            let max_ordinal: u64 = self.max_ordinal_present();
3706            encoder.write_num(max_ordinal, offset);
3707            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3708            // Calling encoder.out_of_line_offset(0) is not allowed.
3709            if max_ordinal == 0 {
3710                return Ok(());
3711            }
3712            depth.increment()?;
3713            let envelope_size = 8;
3714            let bytes_len = max_ordinal as usize * envelope_size;
3715            #[allow(unused_variables)]
3716            let offset = encoder.out_of_line_offset(bytes_len);
3717            let mut _prev_end_offset: usize = 0;
3718            if 1 > max_ordinal {
3719                return Ok(());
3720            }
3721
3722            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3723            // are envelope_size bytes.
3724            let cur_offset: usize = (1 - 1) * envelope_size;
3725
3726            // Zero reserved fields.
3727            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3728
3729            // Safety:
3730            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3731            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3732            //   envelope_size bytes, there is always sufficient room.
3733            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3734                self.element_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3735                encoder,
3736                offset + cur_offset,
3737                depth,
3738            )?;
3739
3740            _prev_end_offset = cur_offset + envelope_size;
3741            if 2 > max_ordinal {
3742                return Ok(());
3743            }
3744
3745            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3746            // are envelope_size bytes.
3747            let cur_offset: usize = (2 - 1) * envelope_size;
3748
3749            // Zero reserved fields.
3750            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3751
3752            // Safety:
3753            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3754            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3755            //   envelope_size bytes, there is always sufficient room.
3756            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_audio__common::DaiFormat, D>(
3757            self.dai_format.as_ref().map(<fidl_fuchsia_hardware_audio__common::DaiFormat as fidl::encoding::ValueTypeMarker>::borrow),
3758            encoder, offset + cur_offset, depth
3759        )?;
3760
3761            _prev_end_offset = cur_offset + envelope_size;
3762
3763            Ok(())
3764        }
3765    }
3766
3767    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3768        for ControlSetDaiFormatRequest
3769    {
3770        #[inline(always)]
3771        fn new_empty() -> Self {
3772            Self::default()
3773        }
3774
3775        unsafe fn decode(
3776            &mut self,
3777            decoder: &mut fidl::encoding::Decoder<'_, D>,
3778            offset: usize,
3779            mut depth: fidl::encoding::Depth,
3780        ) -> fidl::Result<()> {
3781            decoder.debug_check_bounds::<Self>(offset);
3782            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3783                None => return Err(fidl::Error::NotNullable),
3784                Some(len) => len,
3785            };
3786            // Calling decoder.out_of_line_offset(0) is not allowed.
3787            if len == 0 {
3788                return Ok(());
3789            };
3790            depth.increment()?;
3791            let envelope_size = 8;
3792            let bytes_len = len * envelope_size;
3793            let offset = decoder.out_of_line_offset(bytes_len)?;
3794            // Decode the envelope for each type.
3795            let mut _next_ordinal_to_read = 0;
3796            let mut next_offset = offset;
3797            let end_offset = offset + bytes_len;
3798            _next_ordinal_to_read += 1;
3799            if next_offset >= end_offset {
3800                return Ok(());
3801            }
3802
3803            // Decode unknown envelopes for gaps in ordinals.
3804            while _next_ordinal_to_read < 1 {
3805                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3806                _next_ordinal_to_read += 1;
3807                next_offset += envelope_size;
3808            }
3809
3810            let next_out_of_line = decoder.next_out_of_line();
3811            let handles_before = decoder.remaining_handles();
3812            if let Some((inlined, num_bytes, num_handles)) =
3813                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3814            {
3815                let member_inline_size =
3816                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3817                if inlined != (member_inline_size <= 4) {
3818                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3819                }
3820                let inner_offset;
3821                let mut inner_depth = depth.clone();
3822                if inlined {
3823                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3824                    inner_offset = next_offset;
3825                } else {
3826                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3827                    inner_depth.increment()?;
3828                }
3829                let val_ref = self.element_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
3830                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3831                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3832                {
3833                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3834                }
3835                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3836                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3837                }
3838            }
3839
3840            next_offset += envelope_size;
3841            _next_ordinal_to_read += 1;
3842            if next_offset >= end_offset {
3843                return Ok(());
3844            }
3845
3846            // Decode unknown envelopes for gaps in ordinals.
3847            while _next_ordinal_to_read < 2 {
3848                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3849                _next_ordinal_to_read += 1;
3850                next_offset += envelope_size;
3851            }
3852
3853            let next_out_of_line = decoder.next_out_of_line();
3854            let handles_before = decoder.remaining_handles();
3855            if let Some((inlined, num_bytes, num_handles)) =
3856                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3857            {
3858                let member_inline_size = <fidl_fuchsia_hardware_audio__common::DaiFormat as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3859                if inlined != (member_inline_size <= 4) {
3860                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3861                }
3862                let inner_offset;
3863                let mut inner_depth = depth.clone();
3864                if inlined {
3865                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3866                    inner_offset = next_offset;
3867                } else {
3868                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3869                    inner_depth.increment()?;
3870                }
3871                let val_ref = self.dai_format.get_or_insert_with(|| {
3872                    fidl::new_empty!(fidl_fuchsia_hardware_audio__common::DaiFormat, D)
3873                });
3874                fidl::decode!(
3875                    fidl_fuchsia_hardware_audio__common::DaiFormat,
3876                    D,
3877                    val_ref,
3878                    decoder,
3879                    inner_offset,
3880                    inner_depth
3881                )?;
3882                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3883                {
3884                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3885                }
3886                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3887                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3888                }
3889            }
3890
3891            next_offset += envelope_size;
3892
3893            // Decode the remaining unknown envelopes.
3894            while next_offset < end_offset {
3895                _next_ordinal_to_read += 1;
3896                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3897                next_offset += envelope_size;
3898            }
3899
3900            Ok(())
3901        }
3902    }
3903
3904    impl ControlCodecStartResponse {
3905        #[inline(always)]
3906        fn max_ordinal_present(&self) -> u64 {
3907            if let Some(_) = self.start_time {
3908                return 1;
3909            }
3910            0
3911        }
3912    }
3913
3914    impl fidl::encoding::ValueTypeMarker for ControlCodecStartResponse {
3915        type Borrowed<'a> = &'a Self;
3916        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3917            value
3918        }
3919    }
3920
3921    unsafe impl fidl::encoding::TypeMarker for ControlCodecStartResponse {
3922        type Owned = Self;
3923
3924        #[inline(always)]
3925        fn inline_align(_context: fidl::encoding::Context) -> usize {
3926            8
3927        }
3928
3929        #[inline(always)]
3930        fn inline_size(_context: fidl::encoding::Context) -> usize {
3931            16
3932        }
3933    }
3934
3935    unsafe impl<D: fidl::encoding::ResourceDialect>
3936        fidl::encoding::Encode<ControlCodecStartResponse, D> for &ControlCodecStartResponse
3937    {
3938        unsafe fn encode(
3939            self,
3940            encoder: &mut fidl::encoding::Encoder<'_, D>,
3941            offset: usize,
3942            mut depth: fidl::encoding::Depth,
3943        ) -> fidl::Result<()> {
3944            encoder.debug_check_bounds::<ControlCodecStartResponse>(offset);
3945            // Vector header
3946            let max_ordinal: u64 = self.max_ordinal_present();
3947            encoder.write_num(max_ordinal, offset);
3948            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3949            // Calling encoder.out_of_line_offset(0) is not allowed.
3950            if max_ordinal == 0 {
3951                return Ok(());
3952            }
3953            depth.increment()?;
3954            let envelope_size = 8;
3955            let bytes_len = max_ordinal as usize * envelope_size;
3956            #[allow(unused_variables)]
3957            let offset = encoder.out_of_line_offset(bytes_len);
3958            let mut _prev_end_offset: usize = 0;
3959            if 1 > max_ordinal {
3960                return Ok(());
3961            }
3962
3963            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3964            // are envelope_size bytes.
3965            let cur_offset: usize = (1 - 1) * envelope_size;
3966
3967            // Zero reserved fields.
3968            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3969
3970            // Safety:
3971            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3972            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3973            //   envelope_size bytes, there is always sufficient room.
3974            fidl::encoding::encode_in_envelope_optional::<i64, D>(
3975                self.start_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
3976                encoder,
3977                offset + cur_offset,
3978                depth,
3979            )?;
3980
3981            _prev_end_offset = cur_offset + envelope_size;
3982
3983            Ok(())
3984        }
3985    }
3986
3987    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3988        for ControlCodecStartResponse
3989    {
3990        #[inline(always)]
3991        fn new_empty() -> Self {
3992            Self::default()
3993        }
3994
3995        unsafe fn decode(
3996            &mut self,
3997            decoder: &mut fidl::encoding::Decoder<'_, D>,
3998            offset: usize,
3999            mut depth: fidl::encoding::Depth,
4000        ) -> fidl::Result<()> {
4001            decoder.debug_check_bounds::<Self>(offset);
4002            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4003                None => return Err(fidl::Error::NotNullable),
4004                Some(len) => len,
4005            };
4006            // Calling decoder.out_of_line_offset(0) is not allowed.
4007            if len == 0 {
4008                return Ok(());
4009            };
4010            depth.increment()?;
4011            let envelope_size = 8;
4012            let bytes_len = len * envelope_size;
4013            let offset = decoder.out_of_line_offset(bytes_len)?;
4014            // Decode the envelope for each type.
4015            let mut _next_ordinal_to_read = 0;
4016            let mut next_offset = offset;
4017            let end_offset = offset + bytes_len;
4018            _next_ordinal_to_read += 1;
4019            if next_offset >= end_offset {
4020                return Ok(());
4021            }
4022
4023            // Decode unknown envelopes for gaps in ordinals.
4024            while _next_ordinal_to_read < 1 {
4025                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4026                _next_ordinal_to_read += 1;
4027                next_offset += envelope_size;
4028            }
4029
4030            let next_out_of_line = decoder.next_out_of_line();
4031            let handles_before = decoder.remaining_handles();
4032            if let Some((inlined, num_bytes, num_handles)) =
4033                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4034            {
4035                let member_inline_size =
4036                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4037                if inlined != (member_inline_size <= 4) {
4038                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4039                }
4040                let inner_offset;
4041                let mut inner_depth = depth.clone();
4042                if inlined {
4043                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4044                    inner_offset = next_offset;
4045                } else {
4046                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4047                    inner_depth.increment()?;
4048                }
4049                let val_ref = self.start_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
4050                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4051                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4052                {
4053                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4054                }
4055                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4056                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4057                }
4058            }
4059
4060            next_offset += envelope_size;
4061
4062            // Decode the remaining unknown envelopes.
4063            while next_offset < end_offset {
4064                _next_ordinal_to_read += 1;
4065                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4066                next_offset += envelope_size;
4067            }
4068
4069            Ok(())
4070        }
4071    }
4072
4073    impl ControlCodecStopResponse {
4074        #[inline(always)]
4075        fn max_ordinal_present(&self) -> u64 {
4076            if let Some(_) = self.stop_time {
4077                return 1;
4078            }
4079            0
4080        }
4081    }
4082
4083    impl fidl::encoding::ValueTypeMarker for ControlCodecStopResponse {
4084        type Borrowed<'a> = &'a Self;
4085        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4086            value
4087        }
4088    }
4089
4090    unsafe impl fidl::encoding::TypeMarker for ControlCodecStopResponse {
4091        type Owned = Self;
4092
4093        #[inline(always)]
4094        fn inline_align(_context: fidl::encoding::Context) -> usize {
4095            8
4096        }
4097
4098        #[inline(always)]
4099        fn inline_size(_context: fidl::encoding::Context) -> usize {
4100            16
4101        }
4102    }
4103
4104    unsafe impl<D: fidl::encoding::ResourceDialect>
4105        fidl::encoding::Encode<ControlCodecStopResponse, D> for &ControlCodecStopResponse
4106    {
4107        unsafe fn encode(
4108            self,
4109            encoder: &mut fidl::encoding::Encoder<'_, D>,
4110            offset: usize,
4111            mut depth: fidl::encoding::Depth,
4112        ) -> fidl::Result<()> {
4113            encoder.debug_check_bounds::<ControlCodecStopResponse>(offset);
4114            // Vector header
4115            let max_ordinal: u64 = self.max_ordinal_present();
4116            encoder.write_num(max_ordinal, offset);
4117            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4118            // Calling encoder.out_of_line_offset(0) is not allowed.
4119            if max_ordinal == 0 {
4120                return Ok(());
4121            }
4122            depth.increment()?;
4123            let envelope_size = 8;
4124            let bytes_len = max_ordinal as usize * envelope_size;
4125            #[allow(unused_variables)]
4126            let offset = encoder.out_of_line_offset(bytes_len);
4127            let mut _prev_end_offset: usize = 0;
4128            if 1 > max_ordinal {
4129                return Ok(());
4130            }
4131
4132            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4133            // are envelope_size bytes.
4134            let cur_offset: usize = (1 - 1) * envelope_size;
4135
4136            // Zero reserved fields.
4137            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4138
4139            // Safety:
4140            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4141            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4142            //   envelope_size bytes, there is always sufficient room.
4143            fidl::encoding::encode_in_envelope_optional::<i64, D>(
4144                self.stop_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4145                encoder,
4146                offset + cur_offset,
4147                depth,
4148            )?;
4149
4150            _prev_end_offset = cur_offset + envelope_size;
4151
4152            Ok(())
4153        }
4154    }
4155
4156    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4157        for ControlCodecStopResponse
4158    {
4159        #[inline(always)]
4160        fn new_empty() -> Self {
4161            Self::default()
4162        }
4163
4164        unsafe fn decode(
4165            &mut self,
4166            decoder: &mut fidl::encoding::Decoder<'_, D>,
4167            offset: usize,
4168            mut depth: fidl::encoding::Depth,
4169        ) -> fidl::Result<()> {
4170            decoder.debug_check_bounds::<Self>(offset);
4171            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4172                None => return Err(fidl::Error::NotNullable),
4173                Some(len) => len,
4174            };
4175            // Calling decoder.out_of_line_offset(0) is not allowed.
4176            if len == 0 {
4177                return Ok(());
4178            };
4179            depth.increment()?;
4180            let envelope_size = 8;
4181            let bytes_len = len * envelope_size;
4182            let offset = decoder.out_of_line_offset(bytes_len)?;
4183            // Decode the envelope for each type.
4184            let mut _next_ordinal_to_read = 0;
4185            let mut next_offset = offset;
4186            let end_offset = offset + bytes_len;
4187            _next_ordinal_to_read += 1;
4188            if next_offset >= end_offset {
4189                return Ok(());
4190            }
4191
4192            // Decode unknown envelopes for gaps in ordinals.
4193            while _next_ordinal_to_read < 1 {
4194                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4195                _next_ordinal_to_read += 1;
4196                next_offset += envelope_size;
4197            }
4198
4199            let next_out_of_line = decoder.next_out_of_line();
4200            let handles_before = decoder.remaining_handles();
4201            if let Some((inlined, num_bytes, num_handles)) =
4202                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4203            {
4204                let member_inline_size =
4205                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4206                if inlined != (member_inline_size <= 4) {
4207                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4208                }
4209                let inner_offset;
4210                let mut inner_depth = depth.clone();
4211                if inlined {
4212                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4213                    inner_offset = next_offset;
4214                } else {
4215                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4216                    inner_depth.increment()?;
4217                }
4218                let val_ref = self.stop_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
4219                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4220                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4221                {
4222                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4223                }
4224                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4225                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4226                }
4227            }
4228
4229            next_offset += envelope_size;
4230
4231            // Decode the remaining unknown envelopes.
4232            while next_offset < end_offset {
4233                _next_ordinal_to_read += 1;
4234                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4235                next_offset += envelope_size;
4236            }
4237
4238            Ok(())
4239        }
4240    }
4241
4242    impl ControlResetResponse {
4243        #[inline(always)]
4244        fn max_ordinal_present(&self) -> u64 {
4245            0
4246        }
4247    }
4248
4249    impl fidl::encoding::ValueTypeMarker for ControlResetResponse {
4250        type Borrowed<'a> = &'a Self;
4251        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4252            value
4253        }
4254    }
4255
4256    unsafe impl fidl::encoding::TypeMarker for ControlResetResponse {
4257        type Owned = Self;
4258
4259        #[inline(always)]
4260        fn inline_align(_context: fidl::encoding::Context) -> usize {
4261            8
4262        }
4263
4264        #[inline(always)]
4265        fn inline_size(_context: fidl::encoding::Context) -> usize {
4266            16
4267        }
4268    }
4269
4270    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ControlResetResponse, D>
4271        for &ControlResetResponse
4272    {
4273        unsafe fn encode(
4274            self,
4275            encoder: &mut fidl::encoding::Encoder<'_, D>,
4276            offset: usize,
4277            mut depth: fidl::encoding::Depth,
4278        ) -> fidl::Result<()> {
4279            encoder.debug_check_bounds::<ControlResetResponse>(offset);
4280            // Vector header
4281            let max_ordinal: u64 = self.max_ordinal_present();
4282            encoder.write_num(max_ordinal, offset);
4283            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4284            // Calling encoder.out_of_line_offset(0) is not allowed.
4285            if max_ordinal == 0 {
4286                return Ok(());
4287            }
4288            depth.increment()?;
4289            let envelope_size = 8;
4290            let bytes_len = max_ordinal as usize * envelope_size;
4291            #[allow(unused_variables)]
4292            let offset = encoder.out_of_line_offset(bytes_len);
4293            let mut _prev_end_offset: usize = 0;
4294
4295            Ok(())
4296        }
4297    }
4298
4299    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlResetResponse {
4300        #[inline(always)]
4301        fn new_empty() -> Self {
4302            Self::default()
4303        }
4304
4305        unsafe fn decode(
4306            &mut self,
4307            decoder: &mut fidl::encoding::Decoder<'_, D>,
4308            offset: usize,
4309            mut depth: fidl::encoding::Depth,
4310        ) -> fidl::Result<()> {
4311            decoder.debug_check_bounds::<Self>(offset);
4312            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4313                None => return Err(fidl::Error::NotNullable),
4314                Some(len) => len,
4315            };
4316            // Calling decoder.out_of_line_offset(0) is not allowed.
4317            if len == 0 {
4318                return Ok(());
4319            };
4320            depth.increment()?;
4321            let envelope_size = 8;
4322            let bytes_len = len * envelope_size;
4323            let offset = decoder.out_of_line_offset(bytes_len)?;
4324            // Decode the envelope for each type.
4325            let mut _next_ordinal_to_read = 0;
4326            let mut next_offset = offset;
4327            let end_offset = offset + bytes_len;
4328
4329            // Decode the remaining unknown envelopes.
4330            while next_offset < end_offset {
4331                _next_ordinal_to_read += 1;
4332                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4333                next_offset += envelope_size;
4334            }
4335
4336            Ok(())
4337        }
4338    }
4339
4340    impl ControlSetDaiFormatResponse {
4341        #[inline(always)]
4342        fn max_ordinal_present(&self) -> u64 {
4343            if let Some(_) = self.state {
4344                return 1;
4345            }
4346            0
4347        }
4348    }
4349
4350    impl fidl::encoding::ValueTypeMarker for ControlSetDaiFormatResponse {
4351        type Borrowed<'a> = &'a Self;
4352        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4353            value
4354        }
4355    }
4356
4357    unsafe impl fidl::encoding::TypeMarker for ControlSetDaiFormatResponse {
4358        type Owned = Self;
4359
4360        #[inline(always)]
4361        fn inline_align(_context: fidl::encoding::Context) -> usize {
4362            8
4363        }
4364
4365        #[inline(always)]
4366        fn inline_size(_context: fidl::encoding::Context) -> usize {
4367            16
4368        }
4369    }
4370
4371    unsafe impl<D: fidl::encoding::ResourceDialect>
4372        fidl::encoding::Encode<ControlSetDaiFormatResponse, D> for &ControlSetDaiFormatResponse
4373    {
4374        unsafe fn encode(
4375            self,
4376            encoder: &mut fidl::encoding::Encoder<'_, D>,
4377            offset: usize,
4378            mut depth: fidl::encoding::Depth,
4379        ) -> fidl::Result<()> {
4380            encoder.debug_check_bounds::<ControlSetDaiFormatResponse>(offset);
4381            // Vector header
4382            let max_ordinal: u64 = self.max_ordinal_present();
4383            encoder.write_num(max_ordinal, offset);
4384            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4385            // Calling encoder.out_of_line_offset(0) is not allowed.
4386            if max_ordinal == 0 {
4387                return Ok(());
4388            }
4389            depth.increment()?;
4390            let envelope_size = 8;
4391            let bytes_len = max_ordinal as usize * envelope_size;
4392            #[allow(unused_variables)]
4393            let offset = encoder.out_of_line_offset(bytes_len);
4394            let mut _prev_end_offset: usize = 0;
4395            if 1 > max_ordinal {
4396                return Ok(());
4397            }
4398
4399            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4400            // are envelope_size bytes.
4401            let cur_offset: usize = (1 - 1) * envelope_size;
4402
4403            // Zero reserved fields.
4404            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4405
4406            // Safety:
4407            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4408            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4409            //   envelope_size bytes, there is always sufficient room.
4410            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_hardware_audio__common::CodecFormatInfo, D>(
4411            self.state.as_ref().map(<fidl_fuchsia_hardware_audio__common::CodecFormatInfo as fidl::encoding::ValueTypeMarker>::borrow),
4412            encoder, offset + cur_offset, depth
4413        )?;
4414
4415            _prev_end_offset = cur_offset + envelope_size;
4416
4417            Ok(())
4418        }
4419    }
4420
4421    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4422        for ControlSetDaiFormatResponse
4423    {
4424        #[inline(always)]
4425        fn new_empty() -> Self {
4426            Self::default()
4427        }
4428
4429        unsafe fn decode(
4430            &mut self,
4431            decoder: &mut fidl::encoding::Decoder<'_, D>,
4432            offset: usize,
4433            mut depth: fidl::encoding::Depth,
4434        ) -> fidl::Result<()> {
4435            decoder.debug_check_bounds::<Self>(offset);
4436            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4437                None => return Err(fidl::Error::NotNullable),
4438                Some(len) => len,
4439            };
4440            // Calling decoder.out_of_line_offset(0) is not allowed.
4441            if len == 0 {
4442                return Ok(());
4443            };
4444            depth.increment()?;
4445            let envelope_size = 8;
4446            let bytes_len = len * envelope_size;
4447            let offset = decoder.out_of_line_offset(bytes_len)?;
4448            // Decode the envelope for each type.
4449            let mut _next_ordinal_to_read = 0;
4450            let mut next_offset = offset;
4451            let end_offset = offset + bytes_len;
4452            _next_ordinal_to_read += 1;
4453            if next_offset >= end_offset {
4454                return Ok(());
4455            }
4456
4457            // Decode unknown envelopes for gaps in ordinals.
4458            while _next_ordinal_to_read < 1 {
4459                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4460                _next_ordinal_to_read += 1;
4461                next_offset += envelope_size;
4462            }
4463
4464            let next_out_of_line = decoder.next_out_of_line();
4465            let handles_before = decoder.remaining_handles();
4466            if let Some((inlined, num_bytes, num_handles)) =
4467                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4468            {
4469                let member_inline_size = <fidl_fuchsia_hardware_audio__common::CodecFormatInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4470                if inlined != (member_inline_size <= 4) {
4471                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4472                }
4473                let inner_offset;
4474                let mut inner_depth = depth.clone();
4475                if inlined {
4476                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4477                    inner_offset = next_offset;
4478                } else {
4479                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4480                    inner_depth.increment()?;
4481                }
4482                let val_ref = self.state.get_or_insert_with(|| {
4483                    fidl::new_empty!(fidl_fuchsia_hardware_audio__common::CodecFormatInfo, D)
4484                });
4485                fidl::decode!(
4486                    fidl_fuchsia_hardware_audio__common::CodecFormatInfo,
4487                    D,
4488                    val_ref,
4489                    decoder,
4490                    inner_offset,
4491                    inner_depth
4492                )?;
4493                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4494                {
4495                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4496                }
4497                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4498                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4499                }
4500            }
4501
4502            next_offset += envelope_size;
4503
4504            // Decode the remaining unknown envelopes.
4505            while next_offset < end_offset {
4506                _next_ordinal_to_read += 1;
4507                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4508                next_offset += envelope_size;
4509            }
4510
4511            Ok(())
4512        }
4513    }
4514
4515    impl DelayInfo {
4516        #[inline(always)]
4517        fn max_ordinal_present(&self) -> u64 {
4518            if let Some(_) = self.external_delay {
4519                return 2;
4520            }
4521            if let Some(_) = self.internal_delay {
4522                return 1;
4523            }
4524            0
4525        }
4526    }
4527
4528    impl fidl::encoding::ValueTypeMarker for DelayInfo {
4529        type Borrowed<'a> = &'a Self;
4530        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4531            value
4532        }
4533    }
4534
4535    unsafe impl fidl::encoding::TypeMarker for DelayInfo {
4536        type Owned = Self;
4537
4538        #[inline(always)]
4539        fn inline_align(_context: fidl::encoding::Context) -> usize {
4540            8
4541        }
4542
4543        #[inline(always)]
4544        fn inline_size(_context: fidl::encoding::Context) -> usize {
4545            16
4546        }
4547    }
4548
4549    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DelayInfo, D>
4550        for &DelayInfo
4551    {
4552        unsafe fn encode(
4553            self,
4554            encoder: &mut fidl::encoding::Encoder<'_, D>,
4555            offset: usize,
4556            mut depth: fidl::encoding::Depth,
4557        ) -> fidl::Result<()> {
4558            encoder.debug_check_bounds::<DelayInfo>(offset);
4559            // Vector header
4560            let max_ordinal: u64 = self.max_ordinal_present();
4561            encoder.write_num(max_ordinal, offset);
4562            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4563            // Calling encoder.out_of_line_offset(0) is not allowed.
4564            if max_ordinal == 0 {
4565                return Ok(());
4566            }
4567            depth.increment()?;
4568            let envelope_size = 8;
4569            let bytes_len = max_ordinal as usize * envelope_size;
4570            #[allow(unused_variables)]
4571            let offset = encoder.out_of_line_offset(bytes_len);
4572            let mut _prev_end_offset: usize = 0;
4573            if 1 > max_ordinal {
4574                return Ok(());
4575            }
4576
4577            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4578            // are envelope_size bytes.
4579            let cur_offset: usize = (1 - 1) * envelope_size;
4580
4581            // Zero reserved fields.
4582            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4583
4584            // Safety:
4585            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4586            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4587            //   envelope_size bytes, there is always sufficient room.
4588            fidl::encoding::encode_in_envelope_optional::<i64, D>(
4589                self.internal_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4590                encoder,
4591                offset + cur_offset,
4592                depth,
4593            )?;
4594
4595            _prev_end_offset = cur_offset + envelope_size;
4596            if 2 > max_ordinal {
4597                return Ok(());
4598            }
4599
4600            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4601            // are envelope_size bytes.
4602            let cur_offset: usize = (2 - 1) * envelope_size;
4603
4604            // Zero reserved fields.
4605            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4606
4607            // Safety:
4608            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4609            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4610            //   envelope_size bytes, there is always sufficient room.
4611            fidl::encoding::encode_in_envelope_optional::<i64, D>(
4612                self.external_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
4613                encoder,
4614                offset + cur_offset,
4615                depth,
4616            )?;
4617
4618            _prev_end_offset = cur_offset + envelope_size;
4619
4620            Ok(())
4621        }
4622    }
4623
4624    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DelayInfo {
4625        #[inline(always)]
4626        fn new_empty() -> Self {
4627            Self::default()
4628        }
4629
4630        unsafe fn decode(
4631            &mut self,
4632            decoder: &mut fidl::encoding::Decoder<'_, D>,
4633            offset: usize,
4634            mut depth: fidl::encoding::Depth,
4635        ) -> fidl::Result<()> {
4636            decoder.debug_check_bounds::<Self>(offset);
4637            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4638                None => return Err(fidl::Error::NotNullable),
4639                Some(len) => len,
4640            };
4641            // Calling decoder.out_of_line_offset(0) is not allowed.
4642            if len == 0 {
4643                return Ok(());
4644            };
4645            depth.increment()?;
4646            let envelope_size = 8;
4647            let bytes_len = len * envelope_size;
4648            let offset = decoder.out_of_line_offset(bytes_len)?;
4649            // Decode the envelope for each type.
4650            let mut _next_ordinal_to_read = 0;
4651            let mut next_offset = offset;
4652            let end_offset = offset + bytes_len;
4653            _next_ordinal_to_read += 1;
4654            if next_offset >= end_offset {
4655                return Ok(());
4656            }
4657
4658            // Decode unknown envelopes for gaps in ordinals.
4659            while _next_ordinal_to_read < 1 {
4660                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4661                _next_ordinal_to_read += 1;
4662                next_offset += envelope_size;
4663            }
4664
4665            let next_out_of_line = decoder.next_out_of_line();
4666            let handles_before = decoder.remaining_handles();
4667            if let Some((inlined, num_bytes, num_handles)) =
4668                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4669            {
4670                let member_inline_size =
4671                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4672                if inlined != (member_inline_size <= 4) {
4673                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4674                }
4675                let inner_offset;
4676                let mut inner_depth = depth.clone();
4677                if inlined {
4678                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4679                    inner_offset = next_offset;
4680                } else {
4681                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4682                    inner_depth.increment()?;
4683                }
4684                let val_ref = self.internal_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
4685                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4686                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4687                {
4688                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4689                }
4690                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4691                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4692                }
4693            }
4694
4695            next_offset += envelope_size;
4696            _next_ordinal_to_read += 1;
4697            if next_offset >= end_offset {
4698                return Ok(());
4699            }
4700
4701            // Decode unknown envelopes for gaps in ordinals.
4702            while _next_ordinal_to_read < 2 {
4703                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4704                _next_ordinal_to_read += 1;
4705                next_offset += envelope_size;
4706            }
4707
4708            let next_out_of_line = decoder.next_out_of_line();
4709            let handles_before = decoder.remaining_handles();
4710            if let Some((inlined, num_bytes, num_handles)) =
4711                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4712            {
4713                let member_inline_size =
4714                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4715                if inlined != (member_inline_size <= 4) {
4716                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4717                }
4718                let inner_offset;
4719                let mut inner_depth = depth.clone();
4720                if inlined {
4721                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4722                    inner_offset = next_offset;
4723                } else {
4724                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4725                    inner_depth.increment()?;
4726                }
4727                let val_ref = self.external_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
4728                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
4729                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4730                {
4731                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4732                }
4733                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4734                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4735                }
4736            }
4737
4738            next_offset += envelope_size;
4739
4740            // Decode the remaining unknown envelopes.
4741            while next_offset < end_offset {
4742                _next_ordinal_to_read += 1;
4743                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4744                next_offset += envelope_size;
4745            }
4746
4747            Ok(())
4748        }
4749    }
4750
4751    impl ElementDaiFormatSet {
4752        #[inline(always)]
4753        fn max_ordinal_present(&self) -> u64 {
4754            if let Some(_) = self.format_sets {
4755                return 2;
4756            }
4757            if let Some(_) = self.element_id {
4758                return 1;
4759            }
4760            0
4761        }
4762    }
4763
4764    impl fidl::encoding::ValueTypeMarker for ElementDaiFormatSet {
4765        type Borrowed<'a> = &'a Self;
4766        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4767            value
4768        }
4769    }
4770
4771    unsafe impl fidl::encoding::TypeMarker for ElementDaiFormatSet {
4772        type Owned = Self;
4773
4774        #[inline(always)]
4775        fn inline_align(_context: fidl::encoding::Context) -> usize {
4776            8
4777        }
4778
4779        #[inline(always)]
4780        fn inline_size(_context: fidl::encoding::Context) -> usize {
4781            16
4782        }
4783    }
4784
4785    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ElementDaiFormatSet, D>
4786        for &ElementDaiFormatSet
4787    {
4788        unsafe fn encode(
4789            self,
4790            encoder: &mut fidl::encoding::Encoder<'_, D>,
4791            offset: usize,
4792            mut depth: fidl::encoding::Depth,
4793        ) -> fidl::Result<()> {
4794            encoder.debug_check_bounds::<ElementDaiFormatSet>(offset);
4795            // Vector header
4796            let max_ordinal: u64 = self.max_ordinal_present();
4797            encoder.write_num(max_ordinal, offset);
4798            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4799            // Calling encoder.out_of_line_offset(0) is not allowed.
4800            if max_ordinal == 0 {
4801                return Ok(());
4802            }
4803            depth.increment()?;
4804            let envelope_size = 8;
4805            let bytes_len = max_ordinal as usize * envelope_size;
4806            #[allow(unused_variables)]
4807            let offset = encoder.out_of_line_offset(bytes_len);
4808            let mut _prev_end_offset: usize = 0;
4809            if 1 > max_ordinal {
4810                return Ok(());
4811            }
4812
4813            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4814            // are envelope_size bytes.
4815            let cur_offset: usize = (1 - 1) * envelope_size;
4816
4817            // Zero reserved fields.
4818            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4819
4820            // Safety:
4821            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4822            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4823            //   envelope_size bytes, there is always sufficient room.
4824            fidl::encoding::encode_in_envelope_optional::<u64, D>(
4825                self.element_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
4826                encoder,
4827                offset + cur_offset,
4828                depth,
4829            )?;
4830
4831            _prev_end_offset = cur_offset + envelope_size;
4832            if 2 > max_ordinal {
4833                return Ok(());
4834            }
4835
4836            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4837            // are envelope_size bytes.
4838            let cur_offset: usize = (2 - 1) * envelope_size;
4839
4840            // Zero reserved fields.
4841            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4842
4843            // Safety:
4844            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4845            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4846            //   envelope_size bytes, there is always sufficient room.
4847            fidl::encoding::encode_in_envelope_optional::<
4848                fidl::encoding::Vector<
4849                    fidl_fuchsia_hardware_audio__common::DaiSupportedFormats,
4850                    64,
4851                >,
4852                D,
4853            >(
4854                self.format_sets.as_ref().map(
4855                    <fidl::encoding::Vector<
4856                        fidl_fuchsia_hardware_audio__common::DaiSupportedFormats,
4857                        64,
4858                    > as fidl::encoding::ValueTypeMarker>::borrow,
4859                ),
4860                encoder,
4861                offset + cur_offset,
4862                depth,
4863            )?;
4864
4865            _prev_end_offset = cur_offset + envelope_size;
4866
4867            Ok(())
4868        }
4869    }
4870
4871    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ElementDaiFormatSet {
4872        #[inline(always)]
4873        fn new_empty() -> Self {
4874            Self::default()
4875        }
4876
4877        unsafe fn decode(
4878            &mut self,
4879            decoder: &mut fidl::encoding::Decoder<'_, D>,
4880            offset: usize,
4881            mut depth: fidl::encoding::Depth,
4882        ) -> fidl::Result<()> {
4883            decoder.debug_check_bounds::<Self>(offset);
4884            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4885                None => return Err(fidl::Error::NotNullable),
4886                Some(len) => len,
4887            };
4888            // Calling decoder.out_of_line_offset(0) is not allowed.
4889            if len == 0 {
4890                return Ok(());
4891            };
4892            depth.increment()?;
4893            let envelope_size = 8;
4894            let bytes_len = len * envelope_size;
4895            let offset = decoder.out_of_line_offset(bytes_len)?;
4896            // Decode the envelope for each type.
4897            let mut _next_ordinal_to_read = 0;
4898            let mut next_offset = offset;
4899            let end_offset = offset + bytes_len;
4900            _next_ordinal_to_read += 1;
4901            if next_offset >= end_offset {
4902                return Ok(());
4903            }
4904
4905            // Decode unknown envelopes for gaps in ordinals.
4906            while _next_ordinal_to_read < 1 {
4907                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4908                _next_ordinal_to_read += 1;
4909                next_offset += envelope_size;
4910            }
4911
4912            let next_out_of_line = decoder.next_out_of_line();
4913            let handles_before = decoder.remaining_handles();
4914            if let Some((inlined, num_bytes, num_handles)) =
4915                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4916            {
4917                let member_inline_size =
4918                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4919                if inlined != (member_inline_size <= 4) {
4920                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4921                }
4922                let inner_offset;
4923                let mut inner_depth = depth.clone();
4924                if inlined {
4925                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4926                    inner_offset = next_offset;
4927                } else {
4928                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4929                    inner_depth.increment()?;
4930                }
4931                let val_ref = self.element_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
4932                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4933                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4934                {
4935                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4936                }
4937                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4938                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4939                }
4940            }
4941
4942            next_offset += envelope_size;
4943            _next_ordinal_to_read += 1;
4944            if next_offset >= end_offset {
4945                return Ok(());
4946            }
4947
4948            // Decode unknown envelopes for gaps in ordinals.
4949            while _next_ordinal_to_read < 2 {
4950                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4951                _next_ordinal_to_read += 1;
4952                next_offset += envelope_size;
4953            }
4954
4955            let next_out_of_line = decoder.next_out_of_line();
4956            let handles_before = decoder.remaining_handles();
4957            if let Some((inlined, num_bytes, num_handles)) =
4958                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4959            {
4960                let member_inline_size = <fidl::encoding::Vector<
4961                    fidl_fuchsia_hardware_audio__common::DaiSupportedFormats,
4962                    64,
4963                > as fidl::encoding::TypeMarker>::inline_size(
4964                    decoder.context
4965                );
4966                if inlined != (member_inline_size <= 4) {
4967                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4968                }
4969                let inner_offset;
4970                let mut inner_depth = depth.clone();
4971                if inlined {
4972                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4973                    inner_offset = next_offset;
4974                } else {
4975                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4976                    inner_depth.increment()?;
4977                }
4978                let val_ref =
4979                self.format_sets.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio__common::DaiSupportedFormats, 64>, D));
4980                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio__common::DaiSupportedFormats, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
4981                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4982                {
4983                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4984                }
4985                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4986                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4987                }
4988            }
4989
4990            next_offset += envelope_size;
4991
4992            // Decode the remaining unknown envelopes.
4993            while next_offset < end_offset {
4994                _next_ordinal_to_read += 1;
4995                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4996                next_offset += envelope_size;
4997            }
4998
4999            Ok(())
5000        }
5001    }
5002
5003    impl ElementRingBufferFormatSet {
5004        #[inline(always)]
5005        fn max_ordinal_present(&self) -> u64 {
5006            if let Some(_) = self.format_sets {
5007                return 2;
5008            }
5009            if let Some(_) = self.element_id {
5010                return 1;
5011            }
5012            0
5013        }
5014    }
5015
5016    impl fidl::encoding::ValueTypeMarker for ElementRingBufferFormatSet {
5017        type Borrowed<'a> = &'a Self;
5018        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5019            value
5020        }
5021    }
5022
5023    unsafe impl fidl::encoding::TypeMarker for ElementRingBufferFormatSet {
5024        type Owned = Self;
5025
5026        #[inline(always)]
5027        fn inline_align(_context: fidl::encoding::Context) -> usize {
5028            8
5029        }
5030
5031        #[inline(always)]
5032        fn inline_size(_context: fidl::encoding::Context) -> usize {
5033            16
5034        }
5035    }
5036
5037    unsafe impl<D: fidl::encoding::ResourceDialect>
5038        fidl::encoding::Encode<ElementRingBufferFormatSet, D> for &ElementRingBufferFormatSet
5039    {
5040        unsafe fn encode(
5041            self,
5042            encoder: &mut fidl::encoding::Encoder<'_, D>,
5043            offset: usize,
5044            mut depth: fidl::encoding::Depth,
5045        ) -> fidl::Result<()> {
5046            encoder.debug_check_bounds::<ElementRingBufferFormatSet>(offset);
5047            // Vector header
5048            let max_ordinal: u64 = self.max_ordinal_present();
5049            encoder.write_num(max_ordinal, offset);
5050            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5051            // Calling encoder.out_of_line_offset(0) is not allowed.
5052            if max_ordinal == 0 {
5053                return Ok(());
5054            }
5055            depth.increment()?;
5056            let envelope_size = 8;
5057            let bytes_len = max_ordinal as usize * envelope_size;
5058            #[allow(unused_variables)]
5059            let offset = encoder.out_of_line_offset(bytes_len);
5060            let mut _prev_end_offset: usize = 0;
5061            if 1 > max_ordinal {
5062                return Ok(());
5063            }
5064
5065            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5066            // are envelope_size bytes.
5067            let cur_offset: usize = (1 - 1) * envelope_size;
5068
5069            // Zero reserved fields.
5070            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5071
5072            // Safety:
5073            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5074            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5075            //   envelope_size bytes, there is always sufficient room.
5076            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5077                self.element_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5078                encoder,
5079                offset + cur_offset,
5080                depth,
5081            )?;
5082
5083            _prev_end_offset = cur_offset + envelope_size;
5084            if 2 > max_ordinal {
5085                return Ok(());
5086            }
5087
5088            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5089            // are envelope_size bytes.
5090            let cur_offset: usize = (2 - 1) * envelope_size;
5091
5092            // Zero reserved fields.
5093            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5094
5095            // Safety:
5096            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5097            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5098            //   envelope_size bytes, there is always sufficient room.
5099            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<PcmFormatSet, 64>, D>(
5100            self.format_sets.as_ref().map(<fidl::encoding::Vector<PcmFormatSet, 64> as fidl::encoding::ValueTypeMarker>::borrow),
5101            encoder, offset + cur_offset, depth
5102        )?;
5103
5104            _prev_end_offset = cur_offset + envelope_size;
5105
5106            Ok(())
5107        }
5108    }
5109
5110    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5111        for ElementRingBufferFormatSet
5112    {
5113        #[inline(always)]
5114        fn new_empty() -> Self {
5115            Self::default()
5116        }
5117
5118        unsafe fn decode(
5119            &mut self,
5120            decoder: &mut fidl::encoding::Decoder<'_, D>,
5121            offset: usize,
5122            mut depth: fidl::encoding::Depth,
5123        ) -> fidl::Result<()> {
5124            decoder.debug_check_bounds::<Self>(offset);
5125            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5126                None => return Err(fidl::Error::NotNullable),
5127                Some(len) => len,
5128            };
5129            // Calling decoder.out_of_line_offset(0) is not allowed.
5130            if len == 0 {
5131                return Ok(());
5132            };
5133            depth.increment()?;
5134            let envelope_size = 8;
5135            let bytes_len = len * envelope_size;
5136            let offset = decoder.out_of_line_offset(bytes_len)?;
5137            // Decode the envelope for each type.
5138            let mut _next_ordinal_to_read = 0;
5139            let mut next_offset = offset;
5140            let end_offset = offset + bytes_len;
5141            _next_ordinal_to_read += 1;
5142            if next_offset >= end_offset {
5143                return Ok(());
5144            }
5145
5146            // Decode unknown envelopes for gaps in ordinals.
5147            while _next_ordinal_to_read < 1 {
5148                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5149                _next_ordinal_to_read += 1;
5150                next_offset += envelope_size;
5151            }
5152
5153            let next_out_of_line = decoder.next_out_of_line();
5154            let handles_before = decoder.remaining_handles();
5155            if let Some((inlined, num_bytes, num_handles)) =
5156                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5157            {
5158                let member_inline_size =
5159                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5160                if inlined != (member_inline_size <= 4) {
5161                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5162                }
5163                let inner_offset;
5164                let mut inner_depth = depth.clone();
5165                if inlined {
5166                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5167                    inner_offset = next_offset;
5168                } else {
5169                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5170                    inner_depth.increment()?;
5171                }
5172                let val_ref = self.element_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
5173                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5174                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5175                {
5176                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5177                }
5178                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5179                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5180                }
5181            }
5182
5183            next_offset += envelope_size;
5184            _next_ordinal_to_read += 1;
5185            if next_offset >= end_offset {
5186                return Ok(());
5187            }
5188
5189            // Decode unknown envelopes for gaps in ordinals.
5190            while _next_ordinal_to_read < 2 {
5191                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5192                _next_ordinal_to_read += 1;
5193                next_offset += envelope_size;
5194            }
5195
5196            let next_out_of_line = decoder.next_out_of_line();
5197            let handles_before = decoder.remaining_handles();
5198            if let Some((inlined, num_bytes, num_handles)) =
5199                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5200            {
5201                let member_inline_size = <fidl::encoding::Vector<PcmFormatSet, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5202                if inlined != (member_inline_size <= 4) {
5203                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5204                }
5205                let inner_offset;
5206                let mut inner_depth = depth.clone();
5207                if inlined {
5208                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5209                    inner_offset = next_offset;
5210                } else {
5211                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5212                    inner_depth.increment()?;
5213                }
5214                let val_ref = self.format_sets.get_or_insert_with(
5215                    || fidl::new_empty!(fidl::encoding::Vector<PcmFormatSet, 64>, D),
5216                );
5217                fidl::decode!(fidl::encoding::Vector<PcmFormatSet, 64>, 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
5229            // Decode the remaining unknown envelopes.
5230            while next_offset < end_offset {
5231                _next_ordinal_to_read += 1;
5232                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5233                next_offset += envelope_size;
5234            }
5235
5236            Ok(())
5237        }
5238    }
5239
5240    impl Info {
5241        #[inline(always)]
5242        fn max_ordinal_present(&self) -> u64 {
5243            if let Some(_) = self.signal_processing_topologies {
5244                return 13;
5245            }
5246            if let Some(_) = self.signal_processing_elements {
5247                return 12;
5248            }
5249            if let Some(_) = self.clock_domain {
5250                return 11;
5251            }
5252            if let Some(_) = self.plug_detect_caps {
5253                return 10;
5254            }
5255            if let Some(_) = self.dai_format_sets {
5256                return 9;
5257            }
5258            if let Some(_) = self.ring_buffer_format_sets {
5259                return 8;
5260            }
5261            if let Some(_) = self.is_input {
5262                return 7;
5263            }
5264            if let Some(_) = self.unique_instance_id {
5265                return 6;
5266            }
5267            if let Some(_) = self.product {
5268                return 5;
5269            }
5270            if let Some(_) = self.manufacturer {
5271                return 4;
5272            }
5273            if let Some(_) = self.device_name {
5274                return 3;
5275            }
5276            if let Some(_) = self.device_type {
5277                return 2;
5278            }
5279            if let Some(_) = self.token_id {
5280                return 1;
5281            }
5282            0
5283        }
5284    }
5285
5286    impl fidl::encoding::ValueTypeMarker for Info {
5287        type Borrowed<'a> = &'a Self;
5288        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5289            value
5290        }
5291    }
5292
5293    unsafe impl fidl::encoding::TypeMarker for Info {
5294        type Owned = Self;
5295
5296        #[inline(always)]
5297        fn inline_align(_context: fidl::encoding::Context) -> usize {
5298            8
5299        }
5300
5301        #[inline(always)]
5302        fn inline_size(_context: fidl::encoding::Context) -> usize {
5303            16
5304        }
5305    }
5306
5307    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Info, D> for &Info {
5308        unsafe fn encode(
5309            self,
5310            encoder: &mut fidl::encoding::Encoder<'_, D>,
5311            offset: usize,
5312            mut depth: fidl::encoding::Depth,
5313        ) -> fidl::Result<()> {
5314            encoder.debug_check_bounds::<Info>(offset);
5315            // Vector header
5316            let max_ordinal: u64 = self.max_ordinal_present();
5317            encoder.write_num(max_ordinal, offset);
5318            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5319            // Calling encoder.out_of_line_offset(0) is not allowed.
5320            if max_ordinal == 0 {
5321                return Ok(());
5322            }
5323            depth.increment()?;
5324            let envelope_size = 8;
5325            let bytes_len = max_ordinal as usize * envelope_size;
5326            #[allow(unused_variables)]
5327            let offset = encoder.out_of_line_offset(bytes_len);
5328            let mut _prev_end_offset: usize = 0;
5329            if 1 > max_ordinal {
5330                return Ok(());
5331            }
5332
5333            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5334            // are envelope_size bytes.
5335            let cur_offset: usize = (1 - 1) * envelope_size;
5336
5337            // Zero reserved fields.
5338            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5339
5340            // Safety:
5341            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5342            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5343            //   envelope_size bytes, there is always sufficient room.
5344            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5345                self.token_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5346                encoder,
5347                offset + cur_offset,
5348                depth,
5349            )?;
5350
5351            _prev_end_offset = cur_offset + envelope_size;
5352            if 2 > max_ordinal {
5353                return Ok(());
5354            }
5355
5356            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5357            // are envelope_size bytes.
5358            let cur_offset: usize = (2 - 1) * envelope_size;
5359
5360            // Zero reserved fields.
5361            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5362
5363            // Safety:
5364            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5365            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5366            //   envelope_size bytes, there is always sufficient room.
5367            fidl::encoding::encode_in_envelope_optional::<DeviceType, D>(
5368                self.device_type
5369                    .as_ref()
5370                    .map(<DeviceType as fidl::encoding::ValueTypeMarker>::borrow),
5371                encoder,
5372                offset + cur_offset,
5373                depth,
5374            )?;
5375
5376            _prev_end_offset = cur_offset + envelope_size;
5377            if 3 > max_ordinal {
5378                return Ok(());
5379            }
5380
5381            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5382            // are envelope_size bytes.
5383            let cur_offset: usize = (3 - 1) * envelope_size;
5384
5385            // Zero reserved fields.
5386            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5387
5388            // Safety:
5389            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5390            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5391            //   envelope_size bytes, there is always sufficient room.
5392            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
5393                self.device_name.as_ref().map(
5394                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
5395                ),
5396                encoder,
5397                offset + cur_offset,
5398                depth,
5399            )?;
5400
5401            _prev_end_offset = cur_offset + envelope_size;
5402            if 4 > max_ordinal {
5403                return Ok(());
5404            }
5405
5406            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5407            // are envelope_size bytes.
5408            let cur_offset: usize = (4 - 1) * envelope_size;
5409
5410            // Zero reserved fields.
5411            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5412
5413            // Safety:
5414            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5415            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5416            //   envelope_size bytes, there is always sufficient room.
5417            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
5418                self.manufacturer.as_ref().map(
5419                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
5420                ),
5421                encoder,
5422                offset + cur_offset,
5423                depth,
5424            )?;
5425
5426            _prev_end_offset = cur_offset + envelope_size;
5427            if 5 > max_ordinal {
5428                return Ok(());
5429            }
5430
5431            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5432            // are envelope_size bytes.
5433            let cur_offset: usize = (5 - 1) * envelope_size;
5434
5435            // Zero reserved fields.
5436            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5437
5438            // Safety:
5439            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5440            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5441            //   envelope_size bytes, there is always sufficient room.
5442            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
5443                self.product.as_ref().map(
5444                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
5445                ),
5446                encoder,
5447                offset + cur_offset,
5448                depth,
5449            )?;
5450
5451            _prev_end_offset = cur_offset + envelope_size;
5452            if 6 > max_ordinal {
5453                return Ok(());
5454            }
5455
5456            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5457            // are envelope_size bytes.
5458            let cur_offset: usize = (6 - 1) * envelope_size;
5459
5460            // Zero reserved fields.
5461            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5462
5463            // Safety:
5464            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5465            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5466            //   envelope_size bytes, there is always sufficient room.
5467            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 16>, D>(
5468                self.unique_instance_id.as_ref().map(
5469                    <fidl::encoding::Array<u8, 16> as fidl::encoding::ValueTypeMarker>::borrow,
5470                ),
5471                encoder,
5472                offset + cur_offset,
5473                depth,
5474            )?;
5475
5476            _prev_end_offset = cur_offset + envelope_size;
5477            if 7 > max_ordinal {
5478                return Ok(());
5479            }
5480
5481            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5482            // are envelope_size bytes.
5483            let cur_offset: usize = (7 - 1) * envelope_size;
5484
5485            // Zero reserved fields.
5486            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5487
5488            // Safety:
5489            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5490            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5491            //   envelope_size bytes, there is always sufficient room.
5492            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5493                self.is_input.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5494                encoder,
5495                offset + cur_offset,
5496                depth,
5497            )?;
5498
5499            _prev_end_offset = cur_offset + envelope_size;
5500            if 8 > max_ordinal {
5501                return Ok(());
5502            }
5503
5504            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5505            // are envelope_size bytes.
5506            let cur_offset: usize = (8 - 1) * envelope_size;
5507
5508            // Zero reserved fields.
5509            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5510
5511            // Safety:
5512            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5513            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5514            //   envelope_size bytes, there is always sufficient room.
5515            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ElementRingBufferFormatSet, 64>, D>(
5516            self.ring_buffer_format_sets.as_ref().map(<fidl::encoding::Vector<ElementRingBufferFormatSet, 64> as fidl::encoding::ValueTypeMarker>::borrow),
5517            encoder, offset + cur_offset, depth
5518        )?;
5519
5520            _prev_end_offset = cur_offset + envelope_size;
5521            if 9 > 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 = (9 - 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::<fidl::encoding::Vector<ElementDaiFormatSet, 64>, D>(
5537            self.dai_format_sets.as_ref().map(<fidl::encoding::Vector<ElementDaiFormatSet, 64> as fidl::encoding::ValueTypeMarker>::borrow),
5538            encoder, offset + cur_offset, depth
5539        )?;
5540
5541            _prev_end_offset = cur_offset + envelope_size;
5542            if 10 > max_ordinal {
5543                return Ok(());
5544            }
5545
5546            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5547            // are envelope_size bytes.
5548            let cur_offset: usize = (10 - 1) * envelope_size;
5549
5550            // Zero reserved fields.
5551            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5552
5553            // Safety:
5554            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5555            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5556            //   envelope_size bytes, there is always sufficient room.
5557            fidl::encoding::encode_in_envelope_optional::<PlugDetectCapabilities, D>(
5558                self.plug_detect_caps
5559                    .as_ref()
5560                    .map(<PlugDetectCapabilities as fidl::encoding::ValueTypeMarker>::borrow),
5561                encoder,
5562                offset + cur_offset,
5563                depth,
5564            )?;
5565
5566            _prev_end_offset = cur_offset + envelope_size;
5567            if 11 > max_ordinal {
5568                return Ok(());
5569            }
5570
5571            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5572            // are envelope_size bytes.
5573            let cur_offset: usize = (11 - 1) * envelope_size;
5574
5575            // Zero reserved fields.
5576            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5577
5578            // Safety:
5579            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5580            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5581            //   envelope_size bytes, there is always sufficient room.
5582            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5583                self.clock_domain.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5584                encoder,
5585                offset + cur_offset,
5586                depth,
5587            )?;
5588
5589            _prev_end_offset = cur_offset + envelope_size;
5590            if 12 > max_ordinal {
5591                return Ok(());
5592            }
5593
5594            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5595            // are envelope_size bytes.
5596            let cur_offset: usize = (12 - 1) * envelope_size;
5597
5598            // Zero reserved fields.
5599            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5600
5601            // Safety:
5602            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5603            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5604            //   envelope_size bytes, there is always sufficient room.
5605            fidl::encoding::encode_in_envelope_optional::<
5606                fidl::encoding::Vector<
5607                    fidl_fuchsia_hardware_audio_signalprocessing__common::Element,
5608                    64,
5609                >,
5610                D,
5611            >(
5612                self.signal_processing_elements.as_ref().map(
5613                    <fidl::encoding::Vector<
5614                        fidl_fuchsia_hardware_audio_signalprocessing__common::Element,
5615                        64,
5616                    > as fidl::encoding::ValueTypeMarker>::borrow,
5617                ),
5618                encoder,
5619                offset + cur_offset,
5620                depth,
5621            )?;
5622
5623            _prev_end_offset = cur_offset + envelope_size;
5624            if 13 > max_ordinal {
5625                return Ok(());
5626            }
5627
5628            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5629            // are envelope_size bytes.
5630            let cur_offset: usize = (13 - 1) * envelope_size;
5631
5632            // Zero reserved fields.
5633            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5634
5635            // Safety:
5636            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5637            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5638            //   envelope_size bytes, there is always sufficient room.
5639            fidl::encoding::encode_in_envelope_optional::<
5640                fidl::encoding::Vector<
5641                    fidl_fuchsia_hardware_audio_signalprocessing__common::Topology,
5642                    64,
5643                >,
5644                D,
5645            >(
5646                self.signal_processing_topologies.as_ref().map(
5647                    <fidl::encoding::Vector<
5648                        fidl_fuchsia_hardware_audio_signalprocessing__common::Topology,
5649                        64,
5650                    > as fidl::encoding::ValueTypeMarker>::borrow,
5651                ),
5652                encoder,
5653                offset + cur_offset,
5654                depth,
5655            )?;
5656
5657            _prev_end_offset = cur_offset + envelope_size;
5658
5659            Ok(())
5660        }
5661    }
5662
5663    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Info {
5664        #[inline(always)]
5665        fn new_empty() -> Self {
5666            Self::default()
5667        }
5668
5669        unsafe fn decode(
5670            &mut self,
5671            decoder: &mut fidl::encoding::Decoder<'_, D>,
5672            offset: usize,
5673            mut depth: fidl::encoding::Depth,
5674        ) -> fidl::Result<()> {
5675            decoder.debug_check_bounds::<Self>(offset);
5676            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5677                None => return Err(fidl::Error::NotNullable),
5678                Some(len) => len,
5679            };
5680            // Calling decoder.out_of_line_offset(0) is not allowed.
5681            if len == 0 {
5682                return Ok(());
5683            };
5684            depth.increment()?;
5685            let envelope_size = 8;
5686            let bytes_len = len * envelope_size;
5687            let offset = decoder.out_of_line_offset(bytes_len)?;
5688            // Decode the envelope for each type.
5689            let mut _next_ordinal_to_read = 0;
5690            let mut next_offset = offset;
5691            let end_offset = offset + bytes_len;
5692            _next_ordinal_to_read += 1;
5693            if next_offset >= end_offset {
5694                return Ok(());
5695            }
5696
5697            // Decode unknown envelopes for gaps in ordinals.
5698            while _next_ordinal_to_read < 1 {
5699                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5700                _next_ordinal_to_read += 1;
5701                next_offset += envelope_size;
5702            }
5703
5704            let next_out_of_line = decoder.next_out_of_line();
5705            let handles_before = decoder.remaining_handles();
5706            if let Some((inlined, num_bytes, num_handles)) =
5707                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5708            {
5709                let member_inline_size =
5710                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5711                if inlined != (member_inline_size <= 4) {
5712                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5713                }
5714                let inner_offset;
5715                let mut inner_depth = depth.clone();
5716                if inlined {
5717                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5718                    inner_offset = next_offset;
5719                } else {
5720                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5721                    inner_depth.increment()?;
5722                }
5723                let val_ref = self.token_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
5724                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5725                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5726                {
5727                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5728                }
5729                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5730                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5731                }
5732            }
5733
5734            next_offset += envelope_size;
5735            _next_ordinal_to_read += 1;
5736            if next_offset >= end_offset {
5737                return Ok(());
5738            }
5739
5740            // Decode unknown envelopes for gaps in ordinals.
5741            while _next_ordinal_to_read < 2 {
5742                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5743                _next_ordinal_to_read += 1;
5744                next_offset += envelope_size;
5745            }
5746
5747            let next_out_of_line = decoder.next_out_of_line();
5748            let handles_before = decoder.remaining_handles();
5749            if let Some((inlined, num_bytes, num_handles)) =
5750                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5751            {
5752                let member_inline_size =
5753                    <DeviceType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5754                if inlined != (member_inline_size <= 4) {
5755                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5756                }
5757                let inner_offset;
5758                let mut inner_depth = depth.clone();
5759                if inlined {
5760                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5761                    inner_offset = next_offset;
5762                } else {
5763                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5764                    inner_depth.increment()?;
5765                }
5766                let val_ref =
5767                    self.device_type.get_or_insert_with(|| fidl::new_empty!(DeviceType, D));
5768                fidl::decode!(DeviceType, 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 < 3 {
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                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5798                        decoder.context,
5799                    );
5800                if inlined != (member_inline_size <= 4) {
5801                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5802                }
5803                let inner_offset;
5804                let mut inner_depth = depth.clone();
5805                if inlined {
5806                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5807                    inner_offset = next_offset;
5808                } else {
5809                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5810                    inner_depth.increment()?;
5811                }
5812                let val_ref = self
5813                    .device_name
5814                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
5815                fidl::decode!(
5816                    fidl::encoding::BoundedString<256>,
5817                    D,
5818                    val_ref,
5819                    decoder,
5820                    inner_offset,
5821                    inner_depth
5822                )?;
5823                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5824                {
5825                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5826                }
5827                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5828                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5829                }
5830            }
5831
5832            next_offset += envelope_size;
5833            _next_ordinal_to_read += 1;
5834            if next_offset >= end_offset {
5835                return Ok(());
5836            }
5837
5838            // Decode unknown envelopes for gaps in ordinals.
5839            while _next_ordinal_to_read < 4 {
5840                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5841                _next_ordinal_to_read += 1;
5842                next_offset += envelope_size;
5843            }
5844
5845            let next_out_of_line = decoder.next_out_of_line();
5846            let handles_before = decoder.remaining_handles();
5847            if let Some((inlined, num_bytes, num_handles)) =
5848                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5849            {
5850                let member_inline_size =
5851                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5852                        decoder.context,
5853                    );
5854                if inlined != (member_inline_size <= 4) {
5855                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5856                }
5857                let inner_offset;
5858                let mut inner_depth = depth.clone();
5859                if inlined {
5860                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5861                    inner_offset = next_offset;
5862                } else {
5863                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5864                    inner_depth.increment()?;
5865                }
5866                let val_ref = self
5867                    .manufacturer
5868                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
5869                fidl::decode!(
5870                    fidl::encoding::BoundedString<256>,
5871                    D,
5872                    val_ref,
5873                    decoder,
5874                    inner_offset,
5875                    inner_depth
5876                )?;
5877                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5878                {
5879                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5880                }
5881                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5882                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5883                }
5884            }
5885
5886            next_offset += envelope_size;
5887            _next_ordinal_to_read += 1;
5888            if next_offset >= end_offset {
5889                return Ok(());
5890            }
5891
5892            // Decode unknown envelopes for gaps in ordinals.
5893            while _next_ordinal_to_read < 5 {
5894                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5895                _next_ordinal_to_read += 1;
5896                next_offset += envelope_size;
5897            }
5898
5899            let next_out_of_line = decoder.next_out_of_line();
5900            let handles_before = decoder.remaining_handles();
5901            if let Some((inlined, num_bytes, num_handles)) =
5902                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5903            {
5904                let member_inline_size =
5905                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
5906                        decoder.context,
5907                    );
5908                if inlined != (member_inline_size <= 4) {
5909                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5910                }
5911                let inner_offset;
5912                let mut inner_depth = depth.clone();
5913                if inlined {
5914                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5915                    inner_offset = next_offset;
5916                } else {
5917                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5918                    inner_depth.increment()?;
5919                }
5920                let val_ref = self
5921                    .product
5922                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
5923                fidl::decode!(
5924                    fidl::encoding::BoundedString<256>,
5925                    D,
5926                    val_ref,
5927                    decoder,
5928                    inner_offset,
5929                    inner_depth
5930                )?;
5931                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5932                {
5933                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5934                }
5935                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5936                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5937                }
5938            }
5939
5940            next_offset += envelope_size;
5941            _next_ordinal_to_read += 1;
5942            if next_offset >= end_offset {
5943                return Ok(());
5944            }
5945
5946            // Decode unknown envelopes for gaps in ordinals.
5947            while _next_ordinal_to_read < 6 {
5948                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5949                _next_ordinal_to_read += 1;
5950                next_offset += envelope_size;
5951            }
5952
5953            let next_out_of_line = decoder.next_out_of_line();
5954            let handles_before = decoder.remaining_handles();
5955            if let Some((inlined, num_bytes, num_handles)) =
5956                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5957            {
5958                let member_inline_size =
5959                    <fidl::encoding::Array<u8, 16> as fidl::encoding::TypeMarker>::inline_size(
5960                        decoder.context,
5961                    );
5962                if inlined != (member_inline_size <= 4) {
5963                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5964                }
5965                let inner_offset;
5966                let mut inner_depth = depth.clone();
5967                if inlined {
5968                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5969                    inner_offset = next_offset;
5970                } else {
5971                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5972                    inner_depth.increment()?;
5973                }
5974                let val_ref = self
5975                    .unique_instance_id
5976                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 16>, D));
5977                fidl::decode!(fidl::encoding::Array<u8, 16>, D, val_ref, decoder, inner_offset, inner_depth)?;
5978                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5979                {
5980                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5981                }
5982                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5983                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5984                }
5985            }
5986
5987            next_offset += envelope_size;
5988            _next_ordinal_to_read += 1;
5989            if next_offset >= end_offset {
5990                return Ok(());
5991            }
5992
5993            // Decode unknown envelopes for gaps in ordinals.
5994            while _next_ordinal_to_read < 7 {
5995                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5996                _next_ordinal_to_read += 1;
5997                next_offset += envelope_size;
5998            }
5999
6000            let next_out_of_line = decoder.next_out_of_line();
6001            let handles_before = decoder.remaining_handles();
6002            if let Some((inlined, num_bytes, num_handles)) =
6003                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6004            {
6005                let member_inline_size =
6006                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6007                if inlined != (member_inline_size <= 4) {
6008                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6009                }
6010                let inner_offset;
6011                let mut inner_depth = depth.clone();
6012                if inlined {
6013                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6014                    inner_offset = next_offset;
6015                } else {
6016                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6017                    inner_depth.increment()?;
6018                }
6019                let val_ref = self.is_input.get_or_insert_with(|| fidl::new_empty!(bool, D));
6020                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6021                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6022                {
6023                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6024                }
6025                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6026                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6027                }
6028            }
6029
6030            next_offset += envelope_size;
6031            _next_ordinal_to_read += 1;
6032            if next_offset >= end_offset {
6033                return Ok(());
6034            }
6035
6036            // Decode unknown envelopes for gaps in ordinals.
6037            while _next_ordinal_to_read < 8 {
6038                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6039                _next_ordinal_to_read += 1;
6040                next_offset += envelope_size;
6041            }
6042
6043            let next_out_of_line = decoder.next_out_of_line();
6044            let handles_before = decoder.remaining_handles();
6045            if let Some((inlined, num_bytes, num_handles)) =
6046                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6047            {
6048                let member_inline_size = <fidl::encoding::Vector<ElementRingBufferFormatSet, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6049                if inlined != (member_inline_size <= 4) {
6050                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6051                }
6052                let inner_offset;
6053                let mut inner_depth = depth.clone();
6054                if inlined {
6055                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6056                    inner_offset = next_offset;
6057                } else {
6058                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6059                    inner_depth.increment()?;
6060                }
6061                let val_ref = self.ring_buffer_format_sets.get_or_insert_with(
6062                    || fidl::new_empty!(fidl::encoding::Vector<ElementRingBufferFormatSet, 64>, D),
6063                );
6064                fidl::decode!(fidl::encoding::Vector<ElementRingBufferFormatSet, 64>, 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 < 9 {
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<ElementDaiFormatSet, 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.dai_format_sets.get_or_insert_with(
6106                    || fidl::new_empty!(fidl::encoding::Vector<ElementDaiFormatSet, 64>, D),
6107                );
6108                fidl::decode!(fidl::encoding::Vector<ElementDaiFormatSet, 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 < 10 {
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 =
6137                    <PlugDetectCapabilities as fidl::encoding::TypeMarker>::inline_size(
6138                        decoder.context,
6139                    );
6140                if inlined != (member_inline_size <= 4) {
6141                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6142                }
6143                let inner_offset;
6144                let mut inner_depth = depth.clone();
6145                if inlined {
6146                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6147                    inner_offset = next_offset;
6148                } else {
6149                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6150                    inner_depth.increment()?;
6151                }
6152                let val_ref = self
6153                    .plug_detect_caps
6154                    .get_or_insert_with(|| fidl::new_empty!(PlugDetectCapabilities, D));
6155                fidl::decode!(
6156                    PlugDetectCapabilities,
6157                    D,
6158                    val_ref,
6159                    decoder,
6160                    inner_offset,
6161                    inner_depth
6162                )?;
6163                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6164                {
6165                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6166                }
6167                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6168                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6169                }
6170            }
6171
6172            next_offset += envelope_size;
6173            _next_ordinal_to_read += 1;
6174            if next_offset >= end_offset {
6175                return Ok(());
6176            }
6177
6178            // Decode unknown envelopes for gaps in ordinals.
6179            while _next_ordinal_to_read < 11 {
6180                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6181                _next_ordinal_to_read += 1;
6182                next_offset += envelope_size;
6183            }
6184
6185            let next_out_of_line = decoder.next_out_of_line();
6186            let handles_before = decoder.remaining_handles();
6187            if let Some((inlined, num_bytes, num_handles)) =
6188                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6189            {
6190                let member_inline_size =
6191                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6192                if inlined != (member_inline_size <= 4) {
6193                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6194                }
6195                let inner_offset;
6196                let mut inner_depth = depth.clone();
6197                if inlined {
6198                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6199                    inner_offset = next_offset;
6200                } else {
6201                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6202                    inner_depth.increment()?;
6203                }
6204                let val_ref = self.clock_domain.get_or_insert_with(|| fidl::new_empty!(u32, D));
6205                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6206                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6207                {
6208                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6209                }
6210                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6211                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6212                }
6213            }
6214
6215            next_offset += envelope_size;
6216            _next_ordinal_to_read += 1;
6217            if next_offset >= end_offset {
6218                return Ok(());
6219            }
6220
6221            // Decode unknown envelopes for gaps in ordinals.
6222            while _next_ordinal_to_read < 12 {
6223                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6224                _next_ordinal_to_read += 1;
6225                next_offset += envelope_size;
6226            }
6227
6228            let next_out_of_line = decoder.next_out_of_line();
6229            let handles_before = decoder.remaining_handles();
6230            if let Some((inlined, num_bytes, num_handles)) =
6231                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6232            {
6233                let member_inline_size = <fidl::encoding::Vector<
6234                    fidl_fuchsia_hardware_audio_signalprocessing__common::Element,
6235                    64,
6236                > as fidl::encoding::TypeMarker>::inline_size(
6237                    decoder.context
6238                );
6239                if inlined != (member_inline_size <= 4) {
6240                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6241                }
6242                let inner_offset;
6243                let mut inner_depth = depth.clone();
6244                if inlined {
6245                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6246                    inner_offset = next_offset;
6247                } else {
6248                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6249                    inner_depth.increment()?;
6250                }
6251                let val_ref =
6252                self.signal_processing_elements.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio_signalprocessing__common::Element, 64>, D));
6253                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio_signalprocessing__common::Element, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6254                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6255                {
6256                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6257                }
6258                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6259                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6260                }
6261            }
6262
6263            next_offset += envelope_size;
6264            _next_ordinal_to_read += 1;
6265            if next_offset >= end_offset {
6266                return Ok(());
6267            }
6268
6269            // Decode unknown envelopes for gaps in ordinals.
6270            while _next_ordinal_to_read < 13 {
6271                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6272                _next_ordinal_to_read += 1;
6273                next_offset += envelope_size;
6274            }
6275
6276            let next_out_of_line = decoder.next_out_of_line();
6277            let handles_before = decoder.remaining_handles();
6278            if let Some((inlined, num_bytes, num_handles)) =
6279                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6280            {
6281                let member_inline_size = <fidl::encoding::Vector<
6282                    fidl_fuchsia_hardware_audio_signalprocessing__common::Topology,
6283                    64,
6284                > as fidl::encoding::TypeMarker>::inline_size(
6285                    decoder.context
6286                );
6287                if inlined != (member_inline_size <= 4) {
6288                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6289                }
6290                let inner_offset;
6291                let mut inner_depth = depth.clone();
6292                if inlined {
6293                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6294                    inner_offset = next_offset;
6295                } else {
6296                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6297                    inner_depth.increment()?;
6298                }
6299                let val_ref =
6300                self.signal_processing_topologies.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio_signalprocessing__common::Topology, 64>, D));
6301                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_hardware_audio_signalprocessing__common::Topology, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6302                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6303                {
6304                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6305                }
6306                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6307                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6308                }
6309            }
6310
6311            next_offset += envelope_size;
6312
6313            // Decode the remaining unknown envelopes.
6314            while next_offset < end_offset {
6315                _next_ordinal_to_read += 1;
6316                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6317                next_offset += envelope_size;
6318            }
6319
6320            Ok(())
6321        }
6322    }
6323
6324    impl ObserverWatchPlugStateResponse {
6325        #[inline(always)]
6326        fn max_ordinal_present(&self) -> u64 {
6327            if let Some(_) = self.plug_time {
6328                return 2;
6329            }
6330            if let Some(_) = self.state {
6331                return 1;
6332            }
6333            0
6334        }
6335    }
6336
6337    impl fidl::encoding::ValueTypeMarker for ObserverWatchPlugStateResponse {
6338        type Borrowed<'a> = &'a Self;
6339        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6340            value
6341        }
6342    }
6343
6344    unsafe impl fidl::encoding::TypeMarker for ObserverWatchPlugStateResponse {
6345        type Owned = Self;
6346
6347        #[inline(always)]
6348        fn inline_align(_context: fidl::encoding::Context) -> usize {
6349            8
6350        }
6351
6352        #[inline(always)]
6353        fn inline_size(_context: fidl::encoding::Context) -> usize {
6354            16
6355        }
6356    }
6357
6358    unsafe impl<D: fidl::encoding::ResourceDialect>
6359        fidl::encoding::Encode<ObserverWatchPlugStateResponse, D>
6360        for &ObserverWatchPlugStateResponse
6361    {
6362        unsafe fn encode(
6363            self,
6364            encoder: &mut fidl::encoding::Encoder<'_, D>,
6365            offset: usize,
6366            mut depth: fidl::encoding::Depth,
6367        ) -> fidl::Result<()> {
6368            encoder.debug_check_bounds::<ObserverWatchPlugStateResponse>(offset);
6369            // Vector header
6370            let max_ordinal: u64 = self.max_ordinal_present();
6371            encoder.write_num(max_ordinal, offset);
6372            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6373            // Calling encoder.out_of_line_offset(0) is not allowed.
6374            if max_ordinal == 0 {
6375                return Ok(());
6376            }
6377            depth.increment()?;
6378            let envelope_size = 8;
6379            let bytes_len = max_ordinal as usize * envelope_size;
6380            #[allow(unused_variables)]
6381            let offset = encoder.out_of_line_offset(bytes_len);
6382            let mut _prev_end_offset: usize = 0;
6383            if 1 > max_ordinal {
6384                return Ok(());
6385            }
6386
6387            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6388            // are envelope_size bytes.
6389            let cur_offset: usize = (1 - 1) * envelope_size;
6390
6391            // Zero reserved fields.
6392            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6393
6394            // Safety:
6395            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6396            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6397            //   envelope_size bytes, there is always sufficient room.
6398            fidl::encoding::encode_in_envelope_optional::<PlugState, D>(
6399                self.state.as_ref().map(<PlugState as fidl::encoding::ValueTypeMarker>::borrow),
6400                encoder,
6401                offset + cur_offset,
6402                depth,
6403            )?;
6404
6405            _prev_end_offset = cur_offset + envelope_size;
6406            if 2 > max_ordinal {
6407                return Ok(());
6408            }
6409
6410            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6411            // are envelope_size bytes.
6412            let cur_offset: usize = (2 - 1) * envelope_size;
6413
6414            // Zero reserved fields.
6415            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6416
6417            // Safety:
6418            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6419            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6420            //   envelope_size bytes, there is always sufficient room.
6421            fidl::encoding::encode_in_envelope_optional::<i64, D>(
6422                self.plug_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
6423                encoder,
6424                offset + cur_offset,
6425                depth,
6426            )?;
6427
6428            _prev_end_offset = cur_offset + envelope_size;
6429
6430            Ok(())
6431        }
6432    }
6433
6434    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6435        for ObserverWatchPlugStateResponse
6436    {
6437        #[inline(always)]
6438        fn new_empty() -> Self {
6439            Self::default()
6440        }
6441
6442        unsafe fn decode(
6443            &mut self,
6444            decoder: &mut fidl::encoding::Decoder<'_, D>,
6445            offset: usize,
6446            mut depth: fidl::encoding::Depth,
6447        ) -> fidl::Result<()> {
6448            decoder.debug_check_bounds::<Self>(offset);
6449            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6450                None => return Err(fidl::Error::NotNullable),
6451                Some(len) => len,
6452            };
6453            // Calling decoder.out_of_line_offset(0) is not allowed.
6454            if len == 0 {
6455                return Ok(());
6456            };
6457            depth.increment()?;
6458            let envelope_size = 8;
6459            let bytes_len = len * envelope_size;
6460            let offset = decoder.out_of_line_offset(bytes_len)?;
6461            // Decode the envelope for each type.
6462            let mut _next_ordinal_to_read = 0;
6463            let mut next_offset = offset;
6464            let end_offset = offset + bytes_len;
6465            _next_ordinal_to_read += 1;
6466            if next_offset >= end_offset {
6467                return Ok(());
6468            }
6469
6470            // Decode unknown envelopes for gaps in ordinals.
6471            while _next_ordinal_to_read < 1 {
6472                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6473                _next_ordinal_to_read += 1;
6474                next_offset += envelope_size;
6475            }
6476
6477            let next_out_of_line = decoder.next_out_of_line();
6478            let handles_before = decoder.remaining_handles();
6479            if let Some((inlined, num_bytes, num_handles)) =
6480                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6481            {
6482                let member_inline_size =
6483                    <PlugState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6484                if inlined != (member_inline_size <= 4) {
6485                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6486                }
6487                let inner_offset;
6488                let mut inner_depth = depth.clone();
6489                if inlined {
6490                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6491                    inner_offset = next_offset;
6492                } else {
6493                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6494                    inner_depth.increment()?;
6495                }
6496                let val_ref = self.state.get_or_insert_with(|| fidl::new_empty!(PlugState, D));
6497                fidl::decode!(PlugState, D, val_ref, decoder, inner_offset, inner_depth)?;
6498                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6499                {
6500                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6501                }
6502                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6503                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6504                }
6505            }
6506
6507            next_offset += envelope_size;
6508            _next_ordinal_to_read += 1;
6509            if next_offset >= end_offset {
6510                return Ok(());
6511            }
6512
6513            // Decode unknown envelopes for gaps in ordinals.
6514            while _next_ordinal_to_read < 2 {
6515                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6516                _next_ordinal_to_read += 1;
6517                next_offset += envelope_size;
6518            }
6519
6520            let next_out_of_line = decoder.next_out_of_line();
6521            let handles_before = decoder.remaining_handles();
6522            if let Some((inlined, num_bytes, num_handles)) =
6523                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6524            {
6525                let member_inline_size =
6526                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6527                if inlined != (member_inline_size <= 4) {
6528                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6529                }
6530                let inner_offset;
6531                let mut inner_depth = depth.clone();
6532                if inlined {
6533                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6534                    inner_offset = next_offset;
6535                } else {
6536                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6537                    inner_depth.increment()?;
6538                }
6539                let val_ref = self.plug_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
6540                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6541                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6542                {
6543                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6544                }
6545                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6546                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6547                }
6548            }
6549
6550            next_offset += envelope_size;
6551
6552            // Decode the remaining unknown envelopes.
6553            while next_offset < end_offset {
6554                _next_ordinal_to_read += 1;
6555                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6556                next_offset += envelope_size;
6557            }
6558
6559            Ok(())
6560        }
6561    }
6562
6563    impl PcmFormatSet {
6564        #[inline(always)]
6565        fn max_ordinal_present(&self) -> u64 {
6566            if let Some(_) = self.frame_rates {
6567                return 3;
6568            }
6569            if let Some(_) = self.sample_types {
6570                return 2;
6571            }
6572            if let Some(_) = self.channel_sets {
6573                return 1;
6574            }
6575            0
6576        }
6577    }
6578
6579    impl fidl::encoding::ValueTypeMarker for PcmFormatSet {
6580        type Borrowed<'a> = &'a Self;
6581        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6582            value
6583        }
6584    }
6585
6586    unsafe impl fidl::encoding::TypeMarker for PcmFormatSet {
6587        type Owned = Self;
6588
6589        #[inline(always)]
6590        fn inline_align(_context: fidl::encoding::Context) -> usize {
6591            8
6592        }
6593
6594        #[inline(always)]
6595        fn inline_size(_context: fidl::encoding::Context) -> usize {
6596            16
6597        }
6598    }
6599
6600    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PcmFormatSet, D>
6601        for &PcmFormatSet
6602    {
6603        unsafe fn encode(
6604            self,
6605            encoder: &mut fidl::encoding::Encoder<'_, D>,
6606            offset: usize,
6607            mut depth: fidl::encoding::Depth,
6608        ) -> fidl::Result<()> {
6609            encoder.debug_check_bounds::<PcmFormatSet>(offset);
6610            // Vector header
6611            let max_ordinal: u64 = self.max_ordinal_present();
6612            encoder.write_num(max_ordinal, offset);
6613            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6614            // Calling encoder.out_of_line_offset(0) is not allowed.
6615            if max_ordinal == 0 {
6616                return Ok(());
6617            }
6618            depth.increment()?;
6619            let envelope_size = 8;
6620            let bytes_len = max_ordinal as usize * envelope_size;
6621            #[allow(unused_variables)]
6622            let offset = encoder.out_of_line_offset(bytes_len);
6623            let mut _prev_end_offset: usize = 0;
6624            if 1 > max_ordinal {
6625                return Ok(());
6626            }
6627
6628            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6629            // are envelope_size bytes.
6630            let cur_offset: usize = (1 - 1) * envelope_size;
6631
6632            // Zero reserved fields.
6633            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6634
6635            // Safety:
6636            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6637            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6638            //   envelope_size bytes, there is always sufficient room.
6639            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ChannelSet, 64>, D>(
6640            self.channel_sets.as_ref().map(<fidl::encoding::Vector<ChannelSet, 64> as fidl::encoding::ValueTypeMarker>::borrow),
6641            encoder, offset + cur_offset, depth
6642        )?;
6643
6644            _prev_end_offset = cur_offset + envelope_size;
6645            if 2 > max_ordinal {
6646                return Ok(());
6647            }
6648
6649            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6650            // are envelope_size bytes.
6651            let cur_offset: usize = (2 - 1) * envelope_size;
6652
6653            // Zero reserved fields.
6654            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6655
6656            // Safety:
6657            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6658            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6659            //   envelope_size bytes, there is always sufficient room.
6660            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_audio__common::SampleType, 32>, D>(
6661            self.sample_types.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_audio__common::SampleType, 32> as fidl::encoding::ValueTypeMarker>::borrow),
6662            encoder, offset + cur_offset, depth
6663        )?;
6664
6665            _prev_end_offset = cur_offset + envelope_size;
6666            if 3 > max_ordinal {
6667                return Ok(());
6668            }
6669
6670            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6671            // are envelope_size bytes.
6672            let cur_offset: usize = (3 - 1) * envelope_size;
6673
6674            // Zero reserved fields.
6675            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6676
6677            // Safety:
6678            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6679            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6680            //   envelope_size bytes, there is always sufficient room.
6681            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u32, 64>, D>(
6682                self.frame_rates.as_ref().map(
6683                    <fidl::encoding::Vector<u32, 64> as fidl::encoding::ValueTypeMarker>::borrow,
6684                ),
6685                encoder,
6686                offset + cur_offset,
6687                depth,
6688            )?;
6689
6690            _prev_end_offset = cur_offset + envelope_size;
6691
6692            Ok(())
6693        }
6694    }
6695
6696    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PcmFormatSet {
6697        #[inline(always)]
6698        fn new_empty() -> Self {
6699            Self::default()
6700        }
6701
6702        unsafe fn decode(
6703            &mut self,
6704            decoder: &mut fidl::encoding::Decoder<'_, D>,
6705            offset: usize,
6706            mut depth: fidl::encoding::Depth,
6707        ) -> fidl::Result<()> {
6708            decoder.debug_check_bounds::<Self>(offset);
6709            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6710                None => return Err(fidl::Error::NotNullable),
6711                Some(len) => len,
6712            };
6713            // Calling decoder.out_of_line_offset(0) is not allowed.
6714            if len == 0 {
6715                return Ok(());
6716            };
6717            depth.increment()?;
6718            let envelope_size = 8;
6719            let bytes_len = len * envelope_size;
6720            let offset = decoder.out_of_line_offset(bytes_len)?;
6721            // Decode the envelope for each type.
6722            let mut _next_ordinal_to_read = 0;
6723            let mut next_offset = offset;
6724            let end_offset = offset + bytes_len;
6725            _next_ordinal_to_read += 1;
6726            if next_offset >= end_offset {
6727                return Ok(());
6728            }
6729
6730            // Decode unknown envelopes for gaps in ordinals.
6731            while _next_ordinal_to_read < 1 {
6732                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6733                _next_ordinal_to_read += 1;
6734                next_offset += envelope_size;
6735            }
6736
6737            let next_out_of_line = decoder.next_out_of_line();
6738            let handles_before = decoder.remaining_handles();
6739            if let Some((inlined, num_bytes, num_handles)) =
6740                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6741            {
6742                let member_inline_size = <fidl::encoding::Vector<ChannelSet, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6743                if inlined != (member_inline_size <= 4) {
6744                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6745                }
6746                let inner_offset;
6747                let mut inner_depth = depth.clone();
6748                if inlined {
6749                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6750                    inner_offset = next_offset;
6751                } else {
6752                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6753                    inner_depth.increment()?;
6754                }
6755                let val_ref = self.channel_sets.get_or_insert_with(
6756                    || fidl::new_empty!(fidl::encoding::Vector<ChannelSet, 64>, D),
6757                );
6758                fidl::decode!(fidl::encoding::Vector<ChannelSet, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6759                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6760                {
6761                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6762                }
6763                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6764                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6765                }
6766            }
6767
6768            next_offset += envelope_size;
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 < 2 {
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<
6787                    fidl_fuchsia_audio__common::SampleType,
6788                    32,
6789                > as fidl::encoding::TypeMarker>::inline_size(
6790                    decoder.context
6791                );
6792                if inlined != (member_inline_size <= 4) {
6793                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6794                }
6795                let inner_offset;
6796                let mut inner_depth = depth.clone();
6797                if inlined {
6798                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6799                    inner_offset = next_offset;
6800                } else {
6801                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6802                    inner_depth.increment()?;
6803                }
6804                let val_ref =
6805                self.sample_types.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_audio__common::SampleType, 32>, D));
6806                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_audio__common::SampleType, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
6807                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6808                {
6809                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6810                }
6811                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6812                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6813                }
6814            }
6815
6816            next_offset += envelope_size;
6817            _next_ordinal_to_read += 1;
6818            if next_offset >= end_offset {
6819                return Ok(());
6820            }
6821
6822            // Decode unknown envelopes for gaps in ordinals.
6823            while _next_ordinal_to_read < 3 {
6824                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6825                _next_ordinal_to_read += 1;
6826                next_offset += envelope_size;
6827            }
6828
6829            let next_out_of_line = decoder.next_out_of_line();
6830            let handles_before = decoder.remaining_handles();
6831            if let Some((inlined, num_bytes, num_handles)) =
6832                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6833            {
6834                let member_inline_size =
6835                    <fidl::encoding::Vector<u32, 64> as fidl::encoding::TypeMarker>::inline_size(
6836                        decoder.context,
6837                    );
6838                if inlined != (member_inline_size <= 4) {
6839                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6840                }
6841                let inner_offset;
6842                let mut inner_depth = depth.clone();
6843                if inlined {
6844                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6845                    inner_offset = next_offset;
6846                } else {
6847                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6848                    inner_depth.increment()?;
6849                }
6850                let val_ref = self
6851                    .frame_rates
6852                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u32, 64>, D));
6853                fidl::decode!(fidl::encoding::Vector<u32, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
6854                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6855                {
6856                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6857                }
6858                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6859                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6860                }
6861            }
6862
6863            next_offset += envelope_size;
6864
6865            // Decode the remaining unknown envelopes.
6866            while next_offset < end_offset {
6867                _next_ordinal_to_read += 1;
6868                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6869                next_offset += envelope_size;
6870            }
6871
6872            Ok(())
6873        }
6874    }
6875
6876    impl ProviderAddDeviceResponse {
6877        #[inline(always)]
6878        fn max_ordinal_present(&self) -> u64 {
6879            0
6880        }
6881    }
6882
6883    impl fidl::encoding::ValueTypeMarker for ProviderAddDeviceResponse {
6884        type Borrowed<'a> = &'a Self;
6885        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6886            value
6887        }
6888    }
6889
6890    unsafe impl fidl::encoding::TypeMarker for ProviderAddDeviceResponse {
6891        type Owned = Self;
6892
6893        #[inline(always)]
6894        fn inline_align(_context: fidl::encoding::Context) -> usize {
6895            8
6896        }
6897
6898        #[inline(always)]
6899        fn inline_size(_context: fidl::encoding::Context) -> usize {
6900            16
6901        }
6902    }
6903
6904    unsafe impl<D: fidl::encoding::ResourceDialect>
6905        fidl::encoding::Encode<ProviderAddDeviceResponse, D> for &ProviderAddDeviceResponse
6906    {
6907        unsafe fn encode(
6908            self,
6909            encoder: &mut fidl::encoding::Encoder<'_, D>,
6910            offset: usize,
6911            mut depth: fidl::encoding::Depth,
6912        ) -> fidl::Result<()> {
6913            encoder.debug_check_bounds::<ProviderAddDeviceResponse>(offset);
6914            // Vector header
6915            let max_ordinal: u64 = self.max_ordinal_present();
6916            encoder.write_num(max_ordinal, offset);
6917            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6918            // Calling encoder.out_of_line_offset(0) is not allowed.
6919            if max_ordinal == 0 {
6920                return Ok(());
6921            }
6922            depth.increment()?;
6923            let envelope_size = 8;
6924            let bytes_len = max_ordinal as usize * envelope_size;
6925            #[allow(unused_variables)]
6926            let offset = encoder.out_of_line_offset(bytes_len);
6927            let mut _prev_end_offset: usize = 0;
6928
6929            Ok(())
6930        }
6931    }
6932
6933    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6934        for ProviderAddDeviceResponse
6935    {
6936        #[inline(always)]
6937        fn new_empty() -> Self {
6938            Self::default()
6939        }
6940
6941        unsafe fn decode(
6942            &mut self,
6943            decoder: &mut fidl::encoding::Decoder<'_, D>,
6944            offset: usize,
6945            mut depth: fidl::encoding::Depth,
6946        ) -> fidl::Result<()> {
6947            decoder.debug_check_bounds::<Self>(offset);
6948            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6949                None => return Err(fidl::Error::NotNullable),
6950                Some(len) => len,
6951            };
6952            // Calling decoder.out_of_line_offset(0) is not allowed.
6953            if len == 0 {
6954                return Ok(());
6955            };
6956            depth.increment()?;
6957            let envelope_size = 8;
6958            let bytes_len = len * envelope_size;
6959            let offset = decoder.out_of_line_offset(bytes_len)?;
6960            // Decode the envelope for each type.
6961            let mut _next_ordinal_to_read = 0;
6962            let mut next_offset = offset;
6963            let end_offset = offset + bytes_len;
6964
6965            // Decode the remaining unknown envelopes.
6966            while next_offset < end_offset {
6967                _next_ordinal_to_read += 1;
6968                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6969                next_offset += envelope_size;
6970            }
6971
6972            Ok(())
6973        }
6974    }
6975
6976    impl RegistryCreateObserverResponse {
6977        #[inline(always)]
6978        fn max_ordinal_present(&self) -> u64 {
6979            0
6980        }
6981    }
6982
6983    impl fidl::encoding::ValueTypeMarker for RegistryCreateObserverResponse {
6984        type Borrowed<'a> = &'a Self;
6985        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6986            value
6987        }
6988    }
6989
6990    unsafe impl fidl::encoding::TypeMarker for RegistryCreateObserverResponse {
6991        type Owned = Self;
6992
6993        #[inline(always)]
6994        fn inline_align(_context: fidl::encoding::Context) -> usize {
6995            8
6996        }
6997
6998        #[inline(always)]
6999        fn inline_size(_context: fidl::encoding::Context) -> usize {
7000            16
7001        }
7002    }
7003
7004    unsafe impl<D: fidl::encoding::ResourceDialect>
7005        fidl::encoding::Encode<RegistryCreateObserverResponse, D>
7006        for &RegistryCreateObserverResponse
7007    {
7008        unsafe fn encode(
7009            self,
7010            encoder: &mut fidl::encoding::Encoder<'_, D>,
7011            offset: usize,
7012            mut depth: fidl::encoding::Depth,
7013        ) -> fidl::Result<()> {
7014            encoder.debug_check_bounds::<RegistryCreateObserverResponse>(offset);
7015            // Vector header
7016            let max_ordinal: u64 = self.max_ordinal_present();
7017            encoder.write_num(max_ordinal, offset);
7018            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7019            // Calling encoder.out_of_line_offset(0) is not allowed.
7020            if max_ordinal == 0 {
7021                return Ok(());
7022            }
7023            depth.increment()?;
7024            let envelope_size = 8;
7025            let bytes_len = max_ordinal as usize * envelope_size;
7026            #[allow(unused_variables)]
7027            let offset = encoder.out_of_line_offset(bytes_len);
7028            let mut _prev_end_offset: usize = 0;
7029
7030            Ok(())
7031        }
7032    }
7033
7034    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7035        for RegistryCreateObserverResponse
7036    {
7037        #[inline(always)]
7038        fn new_empty() -> Self {
7039            Self::default()
7040        }
7041
7042        unsafe fn decode(
7043            &mut self,
7044            decoder: &mut fidl::encoding::Decoder<'_, D>,
7045            offset: usize,
7046            mut depth: fidl::encoding::Depth,
7047        ) -> fidl::Result<()> {
7048            decoder.debug_check_bounds::<Self>(offset);
7049            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7050                None => return Err(fidl::Error::NotNullable),
7051                Some(len) => len,
7052            };
7053            // Calling decoder.out_of_line_offset(0) is not allowed.
7054            if len == 0 {
7055                return Ok(());
7056            };
7057            depth.increment()?;
7058            let envelope_size = 8;
7059            let bytes_len = len * envelope_size;
7060            let offset = decoder.out_of_line_offset(bytes_len)?;
7061            // Decode the envelope for each type.
7062            let mut _next_ordinal_to_read = 0;
7063            let mut next_offset = offset;
7064            let end_offset = offset + bytes_len;
7065
7066            // Decode the remaining unknown envelopes.
7067            while next_offset < end_offset {
7068                _next_ordinal_to_read += 1;
7069                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7070                next_offset += envelope_size;
7071            }
7072
7073            Ok(())
7074        }
7075    }
7076
7077    impl RegistryWatchDeviceRemovedResponse {
7078        #[inline(always)]
7079        fn max_ordinal_present(&self) -> u64 {
7080            if let Some(_) = self.token_id {
7081                return 1;
7082            }
7083            0
7084        }
7085    }
7086
7087    impl fidl::encoding::ValueTypeMarker for RegistryWatchDeviceRemovedResponse {
7088        type Borrowed<'a> = &'a Self;
7089        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7090            value
7091        }
7092    }
7093
7094    unsafe impl fidl::encoding::TypeMarker for RegistryWatchDeviceRemovedResponse {
7095        type Owned = Self;
7096
7097        #[inline(always)]
7098        fn inline_align(_context: fidl::encoding::Context) -> usize {
7099            8
7100        }
7101
7102        #[inline(always)]
7103        fn inline_size(_context: fidl::encoding::Context) -> usize {
7104            16
7105        }
7106    }
7107
7108    unsafe impl<D: fidl::encoding::ResourceDialect>
7109        fidl::encoding::Encode<RegistryWatchDeviceRemovedResponse, D>
7110        for &RegistryWatchDeviceRemovedResponse
7111    {
7112        unsafe fn encode(
7113            self,
7114            encoder: &mut fidl::encoding::Encoder<'_, D>,
7115            offset: usize,
7116            mut depth: fidl::encoding::Depth,
7117        ) -> fidl::Result<()> {
7118            encoder.debug_check_bounds::<RegistryWatchDeviceRemovedResponse>(offset);
7119            // Vector header
7120            let max_ordinal: u64 = self.max_ordinal_present();
7121            encoder.write_num(max_ordinal, offset);
7122            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7123            // Calling encoder.out_of_line_offset(0) is not allowed.
7124            if max_ordinal == 0 {
7125                return Ok(());
7126            }
7127            depth.increment()?;
7128            let envelope_size = 8;
7129            let bytes_len = max_ordinal as usize * envelope_size;
7130            #[allow(unused_variables)]
7131            let offset = encoder.out_of_line_offset(bytes_len);
7132            let mut _prev_end_offset: usize = 0;
7133            if 1 > max_ordinal {
7134                return Ok(());
7135            }
7136
7137            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7138            // are envelope_size bytes.
7139            let cur_offset: usize = (1 - 1) * envelope_size;
7140
7141            // Zero reserved fields.
7142            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7143
7144            // Safety:
7145            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7146            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7147            //   envelope_size bytes, there is always sufficient room.
7148            fidl::encoding::encode_in_envelope_optional::<u64, D>(
7149                self.token_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
7150                encoder,
7151                offset + cur_offset,
7152                depth,
7153            )?;
7154
7155            _prev_end_offset = cur_offset + envelope_size;
7156
7157            Ok(())
7158        }
7159    }
7160
7161    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7162        for RegistryWatchDeviceRemovedResponse
7163    {
7164        #[inline(always)]
7165        fn new_empty() -> Self {
7166            Self::default()
7167        }
7168
7169        unsafe fn decode(
7170            &mut self,
7171            decoder: &mut fidl::encoding::Decoder<'_, D>,
7172            offset: usize,
7173            mut depth: fidl::encoding::Depth,
7174        ) -> fidl::Result<()> {
7175            decoder.debug_check_bounds::<Self>(offset);
7176            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7177                None => return Err(fidl::Error::NotNullable),
7178                Some(len) => len,
7179            };
7180            // Calling decoder.out_of_line_offset(0) is not allowed.
7181            if len == 0 {
7182                return Ok(());
7183            };
7184            depth.increment()?;
7185            let envelope_size = 8;
7186            let bytes_len = len * envelope_size;
7187            let offset = decoder.out_of_line_offset(bytes_len)?;
7188            // Decode the envelope for each type.
7189            let mut _next_ordinal_to_read = 0;
7190            let mut next_offset = offset;
7191            let end_offset = offset + bytes_len;
7192            _next_ordinal_to_read += 1;
7193            if next_offset >= end_offset {
7194                return Ok(());
7195            }
7196
7197            // Decode unknown envelopes for gaps in ordinals.
7198            while _next_ordinal_to_read < 1 {
7199                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7200                _next_ordinal_to_read += 1;
7201                next_offset += envelope_size;
7202            }
7203
7204            let next_out_of_line = decoder.next_out_of_line();
7205            let handles_before = decoder.remaining_handles();
7206            if let Some((inlined, num_bytes, num_handles)) =
7207                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7208            {
7209                let member_inline_size =
7210                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7211                if inlined != (member_inline_size <= 4) {
7212                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7213                }
7214                let inner_offset;
7215                let mut inner_depth = depth.clone();
7216                if inlined {
7217                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7218                    inner_offset = next_offset;
7219                } else {
7220                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7221                    inner_depth.increment()?;
7222                }
7223                let val_ref = self.token_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
7224                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
7225                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7226                {
7227                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7228                }
7229                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7230                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7231                }
7232            }
7233
7234            next_offset += envelope_size;
7235
7236            // Decode the remaining unknown envelopes.
7237            while next_offset < end_offset {
7238                _next_ordinal_to_read += 1;
7239                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7240                next_offset += envelope_size;
7241            }
7242
7243            Ok(())
7244        }
7245    }
7246
7247    impl RegistryWatchDevicesAddedResponse {
7248        #[inline(always)]
7249        fn max_ordinal_present(&self) -> u64 {
7250            if let Some(_) = self.devices {
7251                return 1;
7252            }
7253            0
7254        }
7255    }
7256
7257    impl fidl::encoding::ValueTypeMarker for RegistryWatchDevicesAddedResponse {
7258        type Borrowed<'a> = &'a Self;
7259        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7260            value
7261        }
7262    }
7263
7264    unsafe impl fidl::encoding::TypeMarker for RegistryWatchDevicesAddedResponse {
7265        type Owned = Self;
7266
7267        #[inline(always)]
7268        fn inline_align(_context: fidl::encoding::Context) -> usize {
7269            8
7270        }
7271
7272        #[inline(always)]
7273        fn inline_size(_context: fidl::encoding::Context) -> usize {
7274            16
7275        }
7276    }
7277
7278    unsafe impl<D: fidl::encoding::ResourceDialect>
7279        fidl::encoding::Encode<RegistryWatchDevicesAddedResponse, D>
7280        for &RegistryWatchDevicesAddedResponse
7281    {
7282        unsafe fn encode(
7283            self,
7284            encoder: &mut fidl::encoding::Encoder<'_, D>,
7285            offset: usize,
7286            mut depth: fidl::encoding::Depth,
7287        ) -> fidl::Result<()> {
7288            encoder.debug_check_bounds::<RegistryWatchDevicesAddedResponse>(offset);
7289            // Vector header
7290            let max_ordinal: u64 = self.max_ordinal_present();
7291            encoder.write_num(max_ordinal, offset);
7292            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7293            // Calling encoder.out_of_line_offset(0) is not allowed.
7294            if max_ordinal == 0 {
7295                return Ok(());
7296            }
7297            depth.increment()?;
7298            let envelope_size = 8;
7299            let bytes_len = max_ordinal as usize * envelope_size;
7300            #[allow(unused_variables)]
7301            let offset = encoder.out_of_line_offset(bytes_len);
7302            let mut _prev_end_offset: usize = 0;
7303            if 1 > max_ordinal {
7304                return Ok(());
7305            }
7306
7307            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7308            // are envelope_size bytes.
7309            let cur_offset: usize = (1 - 1) * envelope_size;
7310
7311            // Zero reserved fields.
7312            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7313
7314            // Safety:
7315            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7316            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7317            //   envelope_size bytes, there is always sufficient room.
7318            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<Info, 256>, D>(
7319                self.devices.as_ref().map(
7320                    <fidl::encoding::Vector<Info, 256> as fidl::encoding::ValueTypeMarker>::borrow,
7321                ),
7322                encoder,
7323                offset + cur_offset,
7324                depth,
7325            )?;
7326
7327            _prev_end_offset = cur_offset + envelope_size;
7328
7329            Ok(())
7330        }
7331    }
7332
7333    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7334        for RegistryWatchDevicesAddedResponse
7335    {
7336        #[inline(always)]
7337        fn new_empty() -> Self {
7338            Self::default()
7339        }
7340
7341        unsafe fn decode(
7342            &mut self,
7343            decoder: &mut fidl::encoding::Decoder<'_, D>,
7344            offset: usize,
7345            mut depth: fidl::encoding::Depth,
7346        ) -> fidl::Result<()> {
7347            decoder.debug_check_bounds::<Self>(offset);
7348            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7349                None => return Err(fidl::Error::NotNullable),
7350                Some(len) => len,
7351            };
7352            // Calling decoder.out_of_line_offset(0) is not allowed.
7353            if len == 0 {
7354                return Ok(());
7355            };
7356            depth.increment()?;
7357            let envelope_size = 8;
7358            let bytes_len = len * envelope_size;
7359            let offset = decoder.out_of_line_offset(bytes_len)?;
7360            // Decode the envelope for each type.
7361            let mut _next_ordinal_to_read = 0;
7362            let mut next_offset = offset;
7363            let end_offset = offset + bytes_len;
7364            _next_ordinal_to_read += 1;
7365            if next_offset >= end_offset {
7366                return Ok(());
7367            }
7368
7369            // Decode unknown envelopes for gaps in ordinals.
7370            while _next_ordinal_to_read < 1 {
7371                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7372                _next_ordinal_to_read += 1;
7373                next_offset += envelope_size;
7374            }
7375
7376            let next_out_of_line = decoder.next_out_of_line();
7377            let handles_before = decoder.remaining_handles();
7378            if let Some((inlined, num_bytes, num_handles)) =
7379                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7380            {
7381                let member_inline_size =
7382                    <fidl::encoding::Vector<Info, 256> as fidl::encoding::TypeMarker>::inline_size(
7383                        decoder.context,
7384                    );
7385                if inlined != (member_inline_size <= 4) {
7386                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7387                }
7388                let inner_offset;
7389                let mut inner_depth = depth.clone();
7390                if inlined {
7391                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7392                    inner_offset = next_offset;
7393                } else {
7394                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7395                    inner_depth.increment()?;
7396                }
7397                let val_ref = self
7398                    .devices
7399                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<Info, 256>, D));
7400                fidl::decode!(fidl::encoding::Vector<Info, 256>, D, val_ref, decoder, inner_offset, inner_depth)?;
7401                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7402                {
7403                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7404                }
7405                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7406                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7407                }
7408            }
7409
7410            next_offset += envelope_size;
7411
7412            // Decode the remaining unknown envelopes.
7413            while next_offset < end_offset {
7414                _next_ordinal_to_read += 1;
7415                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7416                next_offset += envelope_size;
7417            }
7418
7419            Ok(())
7420        }
7421    }
7422
7423    impl RingBufferOptions {
7424        #[inline(always)]
7425        fn max_ordinal_present(&self) -> u64 {
7426            if let Some(_) = self.ring_buffer_min_bytes {
7427                return 2;
7428            }
7429            if let Some(_) = self.format {
7430                return 1;
7431            }
7432            0
7433        }
7434    }
7435
7436    impl fidl::encoding::ValueTypeMarker for RingBufferOptions {
7437        type Borrowed<'a> = &'a Self;
7438        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7439            value
7440        }
7441    }
7442
7443    unsafe impl fidl::encoding::TypeMarker for RingBufferOptions {
7444        type Owned = Self;
7445
7446        #[inline(always)]
7447        fn inline_align(_context: fidl::encoding::Context) -> usize {
7448            8
7449        }
7450
7451        #[inline(always)]
7452        fn inline_size(_context: fidl::encoding::Context) -> usize {
7453            16
7454        }
7455    }
7456
7457    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RingBufferOptions, D>
7458        for &RingBufferOptions
7459    {
7460        unsafe fn encode(
7461            self,
7462            encoder: &mut fidl::encoding::Encoder<'_, D>,
7463            offset: usize,
7464            mut depth: fidl::encoding::Depth,
7465        ) -> fidl::Result<()> {
7466            encoder.debug_check_bounds::<RingBufferOptions>(offset);
7467            // Vector header
7468            let max_ordinal: u64 = self.max_ordinal_present();
7469            encoder.write_num(max_ordinal, offset);
7470            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7471            // Calling encoder.out_of_line_offset(0) is not allowed.
7472            if max_ordinal == 0 {
7473                return Ok(());
7474            }
7475            depth.increment()?;
7476            let envelope_size = 8;
7477            let bytes_len = max_ordinal as usize * envelope_size;
7478            #[allow(unused_variables)]
7479            let offset = encoder.out_of_line_offset(bytes_len);
7480            let mut _prev_end_offset: usize = 0;
7481            if 1 > max_ordinal {
7482                return Ok(());
7483            }
7484
7485            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7486            // are envelope_size bytes.
7487            let cur_offset: usize = (1 - 1) * envelope_size;
7488
7489            // Zero reserved fields.
7490            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7491
7492            // Safety:
7493            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7494            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7495            //   envelope_size bytes, there is always sufficient room.
7496            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_audio__common::Format, D>(
7497                self.format.as_ref().map(
7498                    <fidl_fuchsia_audio__common::Format as fidl::encoding::ValueTypeMarker>::borrow,
7499                ),
7500                encoder,
7501                offset + cur_offset,
7502                depth,
7503            )?;
7504
7505            _prev_end_offset = cur_offset + envelope_size;
7506            if 2 > max_ordinal {
7507                return Ok(());
7508            }
7509
7510            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7511            // are envelope_size bytes.
7512            let cur_offset: usize = (2 - 1) * envelope_size;
7513
7514            // Zero reserved fields.
7515            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7516
7517            // Safety:
7518            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7519            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7520            //   envelope_size bytes, there is always sufficient room.
7521            fidl::encoding::encode_in_envelope_optional::<u32, D>(
7522                self.ring_buffer_min_bytes
7523                    .as_ref()
7524                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
7525                encoder,
7526                offset + cur_offset,
7527                depth,
7528            )?;
7529
7530            _prev_end_offset = cur_offset + envelope_size;
7531
7532            Ok(())
7533        }
7534    }
7535
7536    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferOptions {
7537        #[inline(always)]
7538        fn new_empty() -> Self {
7539            Self::default()
7540        }
7541
7542        unsafe fn decode(
7543            &mut self,
7544            decoder: &mut fidl::encoding::Decoder<'_, D>,
7545            offset: usize,
7546            mut depth: fidl::encoding::Depth,
7547        ) -> fidl::Result<()> {
7548            decoder.debug_check_bounds::<Self>(offset);
7549            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7550                None => return Err(fidl::Error::NotNullable),
7551                Some(len) => len,
7552            };
7553            // Calling decoder.out_of_line_offset(0) is not allowed.
7554            if len == 0 {
7555                return Ok(());
7556            };
7557            depth.increment()?;
7558            let envelope_size = 8;
7559            let bytes_len = len * envelope_size;
7560            let offset = decoder.out_of_line_offset(bytes_len)?;
7561            // Decode the envelope for each type.
7562            let mut _next_ordinal_to_read = 0;
7563            let mut next_offset = offset;
7564            let end_offset = offset + bytes_len;
7565            _next_ordinal_to_read += 1;
7566            if next_offset >= end_offset {
7567                return Ok(());
7568            }
7569
7570            // Decode unknown envelopes for gaps in ordinals.
7571            while _next_ordinal_to_read < 1 {
7572                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7573                _next_ordinal_to_read += 1;
7574                next_offset += envelope_size;
7575            }
7576
7577            let next_out_of_line = decoder.next_out_of_line();
7578            let handles_before = decoder.remaining_handles();
7579            if let Some((inlined, num_bytes, num_handles)) =
7580                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7581            {
7582                let member_inline_size =
7583                    <fidl_fuchsia_audio__common::Format as fidl::encoding::TypeMarker>::inline_size(
7584                        decoder.context,
7585                    );
7586                if inlined != (member_inline_size <= 4) {
7587                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7588                }
7589                let inner_offset;
7590                let mut inner_depth = depth.clone();
7591                if inlined {
7592                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7593                    inner_offset = next_offset;
7594                } else {
7595                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7596                    inner_depth.increment()?;
7597                }
7598                let val_ref = self
7599                    .format
7600                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_audio__common::Format, D));
7601                fidl::decode!(
7602                    fidl_fuchsia_audio__common::Format,
7603                    D,
7604                    val_ref,
7605                    decoder,
7606                    inner_offset,
7607                    inner_depth
7608                )?;
7609                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7610                {
7611                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7612                }
7613                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7614                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7615                }
7616            }
7617
7618            next_offset += envelope_size;
7619            _next_ordinal_to_read += 1;
7620            if next_offset >= end_offset {
7621                return Ok(());
7622            }
7623
7624            // Decode unknown envelopes for gaps in ordinals.
7625            while _next_ordinal_to_read < 2 {
7626                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7627                _next_ordinal_to_read += 1;
7628                next_offset += envelope_size;
7629            }
7630
7631            let next_out_of_line = decoder.next_out_of_line();
7632            let handles_before = decoder.remaining_handles();
7633            if let Some((inlined, num_bytes, num_handles)) =
7634                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7635            {
7636                let member_inline_size =
7637                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7638                if inlined != (member_inline_size <= 4) {
7639                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7640                }
7641                let inner_offset;
7642                let mut inner_depth = depth.clone();
7643                if inlined {
7644                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7645                    inner_offset = next_offset;
7646                } else {
7647                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7648                    inner_depth.increment()?;
7649                }
7650                let val_ref =
7651                    self.ring_buffer_min_bytes.get_or_insert_with(|| fidl::new_empty!(u32, D));
7652                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
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
7664            // Decode the remaining unknown envelopes.
7665            while next_offset < end_offset {
7666                _next_ordinal_to_read += 1;
7667                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7668                next_offset += envelope_size;
7669            }
7670
7671            Ok(())
7672        }
7673    }
7674
7675    impl RingBufferProperties {
7676        #[inline(always)]
7677        fn max_ordinal_present(&self) -> u64 {
7678            if let Some(_) = self.turn_on_delay {
7679                return 2;
7680            }
7681            if let Some(_) = self.valid_bits_per_sample {
7682                return 1;
7683            }
7684            0
7685        }
7686    }
7687
7688    impl fidl::encoding::ValueTypeMarker for RingBufferProperties {
7689        type Borrowed<'a> = &'a Self;
7690        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7691            value
7692        }
7693    }
7694
7695    unsafe impl fidl::encoding::TypeMarker for RingBufferProperties {
7696        type Owned = Self;
7697
7698        #[inline(always)]
7699        fn inline_align(_context: fidl::encoding::Context) -> usize {
7700            8
7701        }
7702
7703        #[inline(always)]
7704        fn inline_size(_context: fidl::encoding::Context) -> usize {
7705            16
7706        }
7707    }
7708
7709    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RingBufferProperties, D>
7710        for &RingBufferProperties
7711    {
7712        unsafe fn encode(
7713            self,
7714            encoder: &mut fidl::encoding::Encoder<'_, D>,
7715            offset: usize,
7716            mut depth: fidl::encoding::Depth,
7717        ) -> fidl::Result<()> {
7718            encoder.debug_check_bounds::<RingBufferProperties>(offset);
7719            // Vector header
7720            let max_ordinal: u64 = self.max_ordinal_present();
7721            encoder.write_num(max_ordinal, offset);
7722            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7723            // Calling encoder.out_of_line_offset(0) is not allowed.
7724            if max_ordinal == 0 {
7725                return Ok(());
7726            }
7727            depth.increment()?;
7728            let envelope_size = 8;
7729            let bytes_len = max_ordinal as usize * envelope_size;
7730            #[allow(unused_variables)]
7731            let offset = encoder.out_of_line_offset(bytes_len);
7732            let mut _prev_end_offset: usize = 0;
7733            if 1 > max_ordinal {
7734                return Ok(());
7735            }
7736
7737            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7738            // are envelope_size bytes.
7739            let cur_offset: usize = (1 - 1) * envelope_size;
7740
7741            // Zero reserved fields.
7742            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7743
7744            // Safety:
7745            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7746            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7747            //   envelope_size bytes, there is always sufficient room.
7748            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7749                self.valid_bits_per_sample
7750                    .as_ref()
7751                    .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7752                encoder,
7753                offset + cur_offset,
7754                depth,
7755            )?;
7756
7757            _prev_end_offset = cur_offset + envelope_size;
7758            if 2 > max_ordinal {
7759                return Ok(());
7760            }
7761
7762            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7763            // are envelope_size bytes.
7764            let cur_offset: usize = (2 - 1) * envelope_size;
7765
7766            // Zero reserved fields.
7767            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7768
7769            // Safety:
7770            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7771            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7772            //   envelope_size bytes, there is always sufficient room.
7773            fidl::encoding::encode_in_envelope_optional::<i64, D>(
7774                self.turn_on_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
7775                encoder,
7776                offset + cur_offset,
7777                depth,
7778            )?;
7779
7780            _prev_end_offset = cur_offset + envelope_size;
7781
7782            Ok(())
7783        }
7784    }
7785
7786    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferProperties {
7787        #[inline(always)]
7788        fn new_empty() -> Self {
7789            Self::default()
7790        }
7791
7792        unsafe fn decode(
7793            &mut self,
7794            decoder: &mut fidl::encoding::Decoder<'_, D>,
7795            offset: usize,
7796            mut depth: fidl::encoding::Depth,
7797        ) -> fidl::Result<()> {
7798            decoder.debug_check_bounds::<Self>(offset);
7799            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7800                None => return Err(fidl::Error::NotNullable),
7801                Some(len) => len,
7802            };
7803            // Calling decoder.out_of_line_offset(0) is not allowed.
7804            if len == 0 {
7805                return Ok(());
7806            };
7807            depth.increment()?;
7808            let envelope_size = 8;
7809            let bytes_len = len * envelope_size;
7810            let offset = decoder.out_of_line_offset(bytes_len)?;
7811            // Decode the envelope for each type.
7812            let mut _next_ordinal_to_read = 0;
7813            let mut next_offset = offset;
7814            let end_offset = offset + bytes_len;
7815            _next_ordinal_to_read += 1;
7816            if next_offset >= end_offset {
7817                return Ok(());
7818            }
7819
7820            // Decode unknown envelopes for gaps in ordinals.
7821            while _next_ordinal_to_read < 1 {
7822                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7823                _next_ordinal_to_read += 1;
7824                next_offset += envelope_size;
7825            }
7826
7827            let next_out_of_line = decoder.next_out_of_line();
7828            let handles_before = decoder.remaining_handles();
7829            if let Some((inlined, num_bytes, num_handles)) =
7830                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7831            {
7832                let member_inline_size =
7833                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7834                if inlined != (member_inline_size <= 4) {
7835                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7836                }
7837                let inner_offset;
7838                let mut inner_depth = depth.clone();
7839                if inlined {
7840                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7841                    inner_offset = next_offset;
7842                } else {
7843                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7844                    inner_depth.increment()?;
7845                }
7846                let val_ref =
7847                    self.valid_bits_per_sample.get_or_insert_with(|| fidl::new_empty!(u8, D));
7848                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7849                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7850                {
7851                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7852                }
7853                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7854                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7855                }
7856            }
7857
7858            next_offset += envelope_size;
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 < 2 {
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                    <i64 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 = self.turn_on_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
7891                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
7892                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7893                {
7894                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7895                }
7896                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7897                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7898                }
7899            }
7900
7901            next_offset += envelope_size;
7902
7903            // Decode the remaining unknown envelopes.
7904            while next_offset < end_offset {
7905                _next_ordinal_to_read += 1;
7906                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7907                next_offset += envelope_size;
7908            }
7909
7910            Ok(())
7911        }
7912    }
7913
7914    impl RingBufferSetActiveChannelsRequest {
7915        #[inline(always)]
7916        fn max_ordinal_present(&self) -> u64 {
7917            if let Some(_) = self.channel_bitmask {
7918                return 1;
7919            }
7920            0
7921        }
7922    }
7923
7924    impl fidl::encoding::ValueTypeMarker for RingBufferSetActiveChannelsRequest {
7925        type Borrowed<'a> = &'a Self;
7926        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7927            value
7928        }
7929    }
7930
7931    unsafe impl fidl::encoding::TypeMarker for RingBufferSetActiveChannelsRequest {
7932        type Owned = Self;
7933
7934        #[inline(always)]
7935        fn inline_align(_context: fidl::encoding::Context) -> usize {
7936            8
7937        }
7938
7939        #[inline(always)]
7940        fn inline_size(_context: fidl::encoding::Context) -> usize {
7941            16
7942        }
7943    }
7944
7945    unsafe impl<D: fidl::encoding::ResourceDialect>
7946        fidl::encoding::Encode<RingBufferSetActiveChannelsRequest, D>
7947        for &RingBufferSetActiveChannelsRequest
7948    {
7949        unsafe fn encode(
7950            self,
7951            encoder: &mut fidl::encoding::Encoder<'_, D>,
7952            offset: usize,
7953            mut depth: fidl::encoding::Depth,
7954        ) -> fidl::Result<()> {
7955            encoder.debug_check_bounds::<RingBufferSetActiveChannelsRequest>(offset);
7956            // Vector header
7957            let max_ordinal: u64 = self.max_ordinal_present();
7958            encoder.write_num(max_ordinal, offset);
7959            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7960            // Calling encoder.out_of_line_offset(0) is not allowed.
7961            if max_ordinal == 0 {
7962                return Ok(());
7963            }
7964            depth.increment()?;
7965            let envelope_size = 8;
7966            let bytes_len = max_ordinal as usize * envelope_size;
7967            #[allow(unused_variables)]
7968            let offset = encoder.out_of_line_offset(bytes_len);
7969            let mut _prev_end_offset: usize = 0;
7970            if 1 > max_ordinal {
7971                return Ok(());
7972            }
7973
7974            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7975            // are envelope_size bytes.
7976            let cur_offset: usize = (1 - 1) * envelope_size;
7977
7978            // Zero reserved fields.
7979            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7980
7981            // Safety:
7982            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7983            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7984            //   envelope_size bytes, there is always sufficient room.
7985            fidl::encoding::encode_in_envelope_optional::<u64, D>(
7986                self.channel_bitmask.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
7987                encoder,
7988                offset + cur_offset,
7989                depth,
7990            )?;
7991
7992            _prev_end_offset = cur_offset + envelope_size;
7993
7994            Ok(())
7995        }
7996    }
7997
7998    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7999        for RingBufferSetActiveChannelsRequest
8000    {
8001        #[inline(always)]
8002        fn new_empty() -> Self {
8003            Self::default()
8004        }
8005
8006        unsafe fn decode(
8007            &mut self,
8008            decoder: &mut fidl::encoding::Decoder<'_, D>,
8009            offset: usize,
8010            mut depth: fidl::encoding::Depth,
8011        ) -> fidl::Result<()> {
8012            decoder.debug_check_bounds::<Self>(offset);
8013            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8014                None => return Err(fidl::Error::NotNullable),
8015                Some(len) => len,
8016            };
8017            // Calling decoder.out_of_line_offset(0) is not allowed.
8018            if len == 0 {
8019                return Ok(());
8020            };
8021            depth.increment()?;
8022            let envelope_size = 8;
8023            let bytes_len = len * envelope_size;
8024            let offset = decoder.out_of_line_offset(bytes_len)?;
8025            // Decode the envelope for each type.
8026            let mut _next_ordinal_to_read = 0;
8027            let mut next_offset = offset;
8028            let end_offset = offset + bytes_len;
8029            _next_ordinal_to_read += 1;
8030            if next_offset >= end_offset {
8031                return Ok(());
8032            }
8033
8034            // Decode unknown envelopes for gaps in ordinals.
8035            while _next_ordinal_to_read < 1 {
8036                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8037                _next_ordinal_to_read += 1;
8038                next_offset += envelope_size;
8039            }
8040
8041            let next_out_of_line = decoder.next_out_of_line();
8042            let handles_before = decoder.remaining_handles();
8043            if let Some((inlined, num_bytes, num_handles)) =
8044                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8045            {
8046                let member_inline_size =
8047                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8048                if inlined != (member_inline_size <= 4) {
8049                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8050                }
8051                let inner_offset;
8052                let mut inner_depth = depth.clone();
8053                if inlined {
8054                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8055                    inner_offset = next_offset;
8056                } else {
8057                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8058                    inner_depth.increment()?;
8059                }
8060                let val_ref = self.channel_bitmask.get_or_insert_with(|| fidl::new_empty!(u64, D));
8061                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
8062                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8063                {
8064                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8065                }
8066                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8067                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8068                }
8069            }
8070
8071            next_offset += envelope_size;
8072
8073            // Decode the remaining unknown envelopes.
8074            while next_offset < end_offset {
8075                _next_ordinal_to_read += 1;
8076                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8077                next_offset += envelope_size;
8078            }
8079
8080            Ok(())
8081        }
8082    }
8083
8084    impl RingBufferStartRequest {
8085        #[inline(always)]
8086        fn max_ordinal_present(&self) -> u64 {
8087            0
8088        }
8089    }
8090
8091    impl fidl::encoding::ValueTypeMarker for RingBufferStartRequest {
8092        type Borrowed<'a> = &'a Self;
8093        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8094            value
8095        }
8096    }
8097
8098    unsafe impl fidl::encoding::TypeMarker for RingBufferStartRequest {
8099        type Owned = Self;
8100
8101        #[inline(always)]
8102        fn inline_align(_context: fidl::encoding::Context) -> usize {
8103            8
8104        }
8105
8106        #[inline(always)]
8107        fn inline_size(_context: fidl::encoding::Context) -> usize {
8108            16
8109        }
8110    }
8111
8112    unsafe impl<D: fidl::encoding::ResourceDialect>
8113        fidl::encoding::Encode<RingBufferStartRequest, D> for &RingBufferStartRequest
8114    {
8115        unsafe fn encode(
8116            self,
8117            encoder: &mut fidl::encoding::Encoder<'_, D>,
8118            offset: usize,
8119            mut depth: fidl::encoding::Depth,
8120        ) -> fidl::Result<()> {
8121            encoder.debug_check_bounds::<RingBufferStartRequest>(offset);
8122            // Vector header
8123            let max_ordinal: u64 = self.max_ordinal_present();
8124            encoder.write_num(max_ordinal, offset);
8125            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8126            // Calling encoder.out_of_line_offset(0) is not allowed.
8127            if max_ordinal == 0 {
8128                return Ok(());
8129            }
8130            depth.increment()?;
8131            let envelope_size = 8;
8132            let bytes_len = max_ordinal as usize * envelope_size;
8133            #[allow(unused_variables)]
8134            let offset = encoder.out_of_line_offset(bytes_len);
8135            let mut _prev_end_offset: usize = 0;
8136
8137            Ok(())
8138        }
8139    }
8140
8141    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8142        for RingBufferStartRequest
8143    {
8144        #[inline(always)]
8145        fn new_empty() -> Self {
8146            Self::default()
8147        }
8148
8149        unsafe fn decode(
8150            &mut self,
8151            decoder: &mut fidl::encoding::Decoder<'_, D>,
8152            offset: usize,
8153            mut depth: fidl::encoding::Depth,
8154        ) -> fidl::Result<()> {
8155            decoder.debug_check_bounds::<Self>(offset);
8156            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8157                None => return Err(fidl::Error::NotNullable),
8158                Some(len) => len,
8159            };
8160            // Calling decoder.out_of_line_offset(0) is not allowed.
8161            if len == 0 {
8162                return Ok(());
8163            };
8164            depth.increment()?;
8165            let envelope_size = 8;
8166            let bytes_len = len * envelope_size;
8167            let offset = decoder.out_of_line_offset(bytes_len)?;
8168            // Decode the envelope for each type.
8169            let mut _next_ordinal_to_read = 0;
8170            let mut next_offset = offset;
8171            let end_offset = offset + bytes_len;
8172
8173            // Decode the remaining unknown envelopes.
8174            while next_offset < end_offset {
8175                _next_ordinal_to_read += 1;
8176                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8177                next_offset += envelope_size;
8178            }
8179
8180            Ok(())
8181        }
8182    }
8183
8184    impl RingBufferStopRequest {
8185        #[inline(always)]
8186        fn max_ordinal_present(&self) -> u64 {
8187            0
8188        }
8189    }
8190
8191    impl fidl::encoding::ValueTypeMarker for RingBufferStopRequest {
8192        type Borrowed<'a> = &'a Self;
8193        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8194            value
8195        }
8196    }
8197
8198    unsafe impl fidl::encoding::TypeMarker for RingBufferStopRequest {
8199        type Owned = Self;
8200
8201        #[inline(always)]
8202        fn inline_align(_context: fidl::encoding::Context) -> usize {
8203            8
8204        }
8205
8206        #[inline(always)]
8207        fn inline_size(_context: fidl::encoding::Context) -> usize {
8208            16
8209        }
8210    }
8211
8212    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RingBufferStopRequest, D>
8213        for &RingBufferStopRequest
8214    {
8215        unsafe fn encode(
8216            self,
8217            encoder: &mut fidl::encoding::Encoder<'_, D>,
8218            offset: usize,
8219            mut depth: fidl::encoding::Depth,
8220        ) -> fidl::Result<()> {
8221            encoder.debug_check_bounds::<RingBufferStopRequest>(offset);
8222            // Vector header
8223            let max_ordinal: u64 = self.max_ordinal_present();
8224            encoder.write_num(max_ordinal, offset);
8225            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8226            // Calling encoder.out_of_line_offset(0) is not allowed.
8227            if max_ordinal == 0 {
8228                return Ok(());
8229            }
8230            depth.increment()?;
8231            let envelope_size = 8;
8232            let bytes_len = max_ordinal as usize * envelope_size;
8233            #[allow(unused_variables)]
8234            let offset = encoder.out_of_line_offset(bytes_len);
8235            let mut _prev_end_offset: usize = 0;
8236
8237            Ok(())
8238        }
8239    }
8240
8241    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RingBufferStopRequest {
8242        #[inline(always)]
8243        fn new_empty() -> Self {
8244            Self::default()
8245        }
8246
8247        unsafe fn decode(
8248            &mut self,
8249            decoder: &mut fidl::encoding::Decoder<'_, D>,
8250            offset: usize,
8251            mut depth: fidl::encoding::Depth,
8252        ) -> fidl::Result<()> {
8253            decoder.debug_check_bounds::<Self>(offset);
8254            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8255                None => return Err(fidl::Error::NotNullable),
8256                Some(len) => len,
8257            };
8258            // Calling decoder.out_of_line_offset(0) is not allowed.
8259            if len == 0 {
8260                return Ok(());
8261            };
8262            depth.increment()?;
8263            let envelope_size = 8;
8264            let bytes_len = len * envelope_size;
8265            let offset = decoder.out_of_line_offset(bytes_len)?;
8266            // Decode the envelope for each type.
8267            let mut _next_ordinal_to_read = 0;
8268            let mut next_offset = offset;
8269            let end_offset = offset + bytes_len;
8270
8271            // Decode the remaining unknown envelopes.
8272            while next_offset < end_offset {
8273                _next_ordinal_to_read += 1;
8274                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8275                next_offset += envelope_size;
8276            }
8277
8278            Ok(())
8279        }
8280    }
8281
8282    impl RingBufferSetActiveChannelsResponse {
8283        #[inline(always)]
8284        fn max_ordinal_present(&self) -> u64 {
8285            if let Some(_) = self.set_time {
8286                return 1;
8287            }
8288            0
8289        }
8290    }
8291
8292    impl fidl::encoding::ValueTypeMarker for RingBufferSetActiveChannelsResponse {
8293        type Borrowed<'a> = &'a Self;
8294        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8295            value
8296        }
8297    }
8298
8299    unsafe impl fidl::encoding::TypeMarker for RingBufferSetActiveChannelsResponse {
8300        type Owned = Self;
8301
8302        #[inline(always)]
8303        fn inline_align(_context: fidl::encoding::Context) -> usize {
8304            8
8305        }
8306
8307        #[inline(always)]
8308        fn inline_size(_context: fidl::encoding::Context) -> usize {
8309            16
8310        }
8311    }
8312
8313    unsafe impl<D: fidl::encoding::ResourceDialect>
8314        fidl::encoding::Encode<RingBufferSetActiveChannelsResponse, D>
8315        for &RingBufferSetActiveChannelsResponse
8316    {
8317        unsafe fn encode(
8318            self,
8319            encoder: &mut fidl::encoding::Encoder<'_, D>,
8320            offset: usize,
8321            mut depth: fidl::encoding::Depth,
8322        ) -> fidl::Result<()> {
8323            encoder.debug_check_bounds::<RingBufferSetActiveChannelsResponse>(offset);
8324            // Vector header
8325            let max_ordinal: u64 = self.max_ordinal_present();
8326            encoder.write_num(max_ordinal, offset);
8327            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8328            // Calling encoder.out_of_line_offset(0) is not allowed.
8329            if max_ordinal == 0 {
8330                return Ok(());
8331            }
8332            depth.increment()?;
8333            let envelope_size = 8;
8334            let bytes_len = max_ordinal as usize * envelope_size;
8335            #[allow(unused_variables)]
8336            let offset = encoder.out_of_line_offset(bytes_len);
8337            let mut _prev_end_offset: usize = 0;
8338            if 1 > max_ordinal {
8339                return Ok(());
8340            }
8341
8342            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8343            // are envelope_size bytes.
8344            let cur_offset: usize = (1 - 1) * envelope_size;
8345
8346            // Zero reserved fields.
8347            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8348
8349            // Safety:
8350            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8351            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8352            //   envelope_size bytes, there is always sufficient room.
8353            fidl::encoding::encode_in_envelope_optional::<i64, D>(
8354                self.set_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
8355                encoder,
8356                offset + cur_offset,
8357                depth,
8358            )?;
8359
8360            _prev_end_offset = cur_offset + envelope_size;
8361
8362            Ok(())
8363        }
8364    }
8365
8366    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8367        for RingBufferSetActiveChannelsResponse
8368    {
8369        #[inline(always)]
8370        fn new_empty() -> Self {
8371            Self::default()
8372        }
8373
8374        unsafe fn decode(
8375            &mut self,
8376            decoder: &mut fidl::encoding::Decoder<'_, D>,
8377            offset: usize,
8378            mut depth: fidl::encoding::Depth,
8379        ) -> fidl::Result<()> {
8380            decoder.debug_check_bounds::<Self>(offset);
8381            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8382                None => return Err(fidl::Error::NotNullable),
8383                Some(len) => len,
8384            };
8385            // Calling decoder.out_of_line_offset(0) is not allowed.
8386            if len == 0 {
8387                return Ok(());
8388            };
8389            depth.increment()?;
8390            let envelope_size = 8;
8391            let bytes_len = len * envelope_size;
8392            let offset = decoder.out_of_line_offset(bytes_len)?;
8393            // Decode the envelope for each type.
8394            let mut _next_ordinal_to_read = 0;
8395            let mut next_offset = offset;
8396            let end_offset = offset + bytes_len;
8397            _next_ordinal_to_read += 1;
8398            if next_offset >= end_offset {
8399                return Ok(());
8400            }
8401
8402            // Decode unknown envelopes for gaps in ordinals.
8403            while _next_ordinal_to_read < 1 {
8404                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8405                _next_ordinal_to_read += 1;
8406                next_offset += envelope_size;
8407            }
8408
8409            let next_out_of_line = decoder.next_out_of_line();
8410            let handles_before = decoder.remaining_handles();
8411            if let Some((inlined, num_bytes, num_handles)) =
8412                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8413            {
8414                let member_inline_size =
8415                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8416                if inlined != (member_inline_size <= 4) {
8417                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8418                }
8419                let inner_offset;
8420                let mut inner_depth = depth.clone();
8421                if inlined {
8422                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8423                    inner_offset = next_offset;
8424                } else {
8425                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8426                    inner_depth.increment()?;
8427                }
8428                let val_ref = self.set_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
8429                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
8430                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8431                {
8432                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8433                }
8434                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8435                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8436                }
8437            }
8438
8439            next_offset += envelope_size;
8440
8441            // Decode the remaining unknown envelopes.
8442            while next_offset < end_offset {
8443                _next_ordinal_to_read += 1;
8444                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8445                next_offset += envelope_size;
8446            }
8447
8448            Ok(())
8449        }
8450    }
8451
8452    impl RingBufferStartResponse {
8453        #[inline(always)]
8454        fn max_ordinal_present(&self) -> u64 {
8455            if let Some(_) = self.start_time {
8456                return 1;
8457            }
8458            0
8459        }
8460    }
8461
8462    impl fidl::encoding::ValueTypeMarker for RingBufferStartResponse {
8463        type Borrowed<'a> = &'a Self;
8464        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8465            value
8466        }
8467    }
8468
8469    unsafe impl fidl::encoding::TypeMarker for RingBufferStartResponse {
8470        type Owned = Self;
8471
8472        #[inline(always)]
8473        fn inline_align(_context: fidl::encoding::Context) -> usize {
8474            8
8475        }
8476
8477        #[inline(always)]
8478        fn inline_size(_context: fidl::encoding::Context) -> usize {
8479            16
8480        }
8481    }
8482
8483    unsafe impl<D: fidl::encoding::ResourceDialect>
8484        fidl::encoding::Encode<RingBufferStartResponse, D> for &RingBufferStartResponse
8485    {
8486        unsafe fn encode(
8487            self,
8488            encoder: &mut fidl::encoding::Encoder<'_, D>,
8489            offset: usize,
8490            mut depth: fidl::encoding::Depth,
8491        ) -> fidl::Result<()> {
8492            encoder.debug_check_bounds::<RingBufferStartResponse>(offset);
8493            // Vector header
8494            let max_ordinal: u64 = self.max_ordinal_present();
8495            encoder.write_num(max_ordinal, offset);
8496            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8497            // Calling encoder.out_of_line_offset(0) is not allowed.
8498            if max_ordinal == 0 {
8499                return Ok(());
8500            }
8501            depth.increment()?;
8502            let envelope_size = 8;
8503            let bytes_len = max_ordinal as usize * envelope_size;
8504            #[allow(unused_variables)]
8505            let offset = encoder.out_of_line_offset(bytes_len);
8506            let mut _prev_end_offset: usize = 0;
8507            if 1 > max_ordinal {
8508                return Ok(());
8509            }
8510
8511            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8512            // are envelope_size bytes.
8513            let cur_offset: usize = (1 - 1) * envelope_size;
8514
8515            // Zero reserved fields.
8516            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8517
8518            // Safety:
8519            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8520            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8521            //   envelope_size bytes, there is always sufficient room.
8522            fidl::encoding::encode_in_envelope_optional::<i64, D>(
8523                self.start_time.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
8524                encoder,
8525                offset + cur_offset,
8526                depth,
8527            )?;
8528
8529            _prev_end_offset = cur_offset + envelope_size;
8530
8531            Ok(())
8532        }
8533    }
8534
8535    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8536        for RingBufferStartResponse
8537    {
8538        #[inline(always)]
8539        fn new_empty() -> Self {
8540            Self::default()
8541        }
8542
8543        unsafe fn decode(
8544            &mut self,
8545            decoder: &mut fidl::encoding::Decoder<'_, D>,
8546            offset: usize,
8547            mut depth: fidl::encoding::Depth,
8548        ) -> fidl::Result<()> {
8549            decoder.debug_check_bounds::<Self>(offset);
8550            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8551                None => return Err(fidl::Error::NotNullable),
8552                Some(len) => len,
8553            };
8554            // Calling decoder.out_of_line_offset(0) is not allowed.
8555            if len == 0 {
8556                return Ok(());
8557            };
8558            depth.increment()?;
8559            let envelope_size = 8;
8560            let bytes_len = len * envelope_size;
8561            let offset = decoder.out_of_line_offset(bytes_len)?;
8562            // Decode the envelope for each type.
8563            let mut _next_ordinal_to_read = 0;
8564            let mut next_offset = offset;
8565            let end_offset = offset + bytes_len;
8566            _next_ordinal_to_read += 1;
8567            if next_offset >= end_offset {
8568                return Ok(());
8569            }
8570
8571            // Decode unknown envelopes for gaps in ordinals.
8572            while _next_ordinal_to_read < 1 {
8573                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8574                _next_ordinal_to_read += 1;
8575                next_offset += envelope_size;
8576            }
8577
8578            let next_out_of_line = decoder.next_out_of_line();
8579            let handles_before = decoder.remaining_handles();
8580            if let Some((inlined, num_bytes, num_handles)) =
8581                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8582            {
8583                let member_inline_size =
8584                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8585                if inlined != (member_inline_size <= 4) {
8586                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8587                }
8588                let inner_offset;
8589                let mut inner_depth = depth.clone();
8590                if inlined {
8591                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8592                    inner_offset = next_offset;
8593                } else {
8594                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8595                    inner_depth.increment()?;
8596                }
8597                let val_ref = self.start_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
8598                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
8599                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8600                {
8601                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8602                }
8603                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8604                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8605                }
8606            }
8607
8608            next_offset += envelope_size;
8609
8610            // Decode the remaining unknown envelopes.
8611            while next_offset < end_offset {
8612                _next_ordinal_to_read += 1;
8613                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8614                next_offset += envelope_size;
8615            }
8616
8617            Ok(())
8618        }
8619    }
8620
8621    impl RingBufferStopResponse {
8622        #[inline(always)]
8623        fn max_ordinal_present(&self) -> u64 {
8624            0
8625        }
8626    }
8627
8628    impl fidl::encoding::ValueTypeMarker for RingBufferStopResponse {
8629        type Borrowed<'a> = &'a Self;
8630        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8631            value
8632        }
8633    }
8634
8635    unsafe impl fidl::encoding::TypeMarker for RingBufferStopResponse {
8636        type Owned = Self;
8637
8638        #[inline(always)]
8639        fn inline_align(_context: fidl::encoding::Context) -> usize {
8640            8
8641        }
8642
8643        #[inline(always)]
8644        fn inline_size(_context: fidl::encoding::Context) -> usize {
8645            16
8646        }
8647    }
8648
8649    unsafe impl<D: fidl::encoding::ResourceDialect>
8650        fidl::encoding::Encode<RingBufferStopResponse, D> for &RingBufferStopResponse
8651    {
8652        unsafe fn encode(
8653            self,
8654            encoder: &mut fidl::encoding::Encoder<'_, D>,
8655            offset: usize,
8656            mut depth: fidl::encoding::Depth,
8657        ) -> fidl::Result<()> {
8658            encoder.debug_check_bounds::<RingBufferStopResponse>(offset);
8659            // Vector header
8660            let max_ordinal: u64 = self.max_ordinal_present();
8661            encoder.write_num(max_ordinal, offset);
8662            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8663            // Calling encoder.out_of_line_offset(0) is not allowed.
8664            if max_ordinal == 0 {
8665                return Ok(());
8666            }
8667            depth.increment()?;
8668            let envelope_size = 8;
8669            let bytes_len = max_ordinal as usize * envelope_size;
8670            #[allow(unused_variables)]
8671            let offset = encoder.out_of_line_offset(bytes_len);
8672            let mut _prev_end_offset: usize = 0;
8673
8674            Ok(())
8675        }
8676    }
8677
8678    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8679        for RingBufferStopResponse
8680    {
8681        #[inline(always)]
8682        fn new_empty() -> Self {
8683            Self::default()
8684        }
8685
8686        unsafe fn decode(
8687            &mut self,
8688            decoder: &mut fidl::encoding::Decoder<'_, D>,
8689            offset: usize,
8690            mut depth: fidl::encoding::Depth,
8691        ) -> fidl::Result<()> {
8692            decoder.debug_check_bounds::<Self>(offset);
8693            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8694                None => return Err(fidl::Error::NotNullable),
8695                Some(len) => len,
8696            };
8697            // Calling decoder.out_of_line_offset(0) is not allowed.
8698            if len == 0 {
8699                return Ok(());
8700            };
8701            depth.increment()?;
8702            let envelope_size = 8;
8703            let bytes_len = len * envelope_size;
8704            let offset = decoder.out_of_line_offset(bytes_len)?;
8705            // Decode the envelope for each type.
8706            let mut _next_ordinal_to_read = 0;
8707            let mut next_offset = offset;
8708            let end_offset = offset + bytes_len;
8709
8710            // Decode the remaining unknown envelopes.
8711            while next_offset < end_offset {
8712                _next_ordinal_to_read += 1;
8713                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8714                next_offset += envelope_size;
8715            }
8716
8717            Ok(())
8718        }
8719    }
8720
8721    impl RingBufferWatchDelayInfoResponse {
8722        #[inline(always)]
8723        fn max_ordinal_present(&self) -> u64 {
8724            if let Some(_) = self.delay_info {
8725                return 1;
8726            }
8727            0
8728        }
8729    }
8730
8731    impl fidl::encoding::ValueTypeMarker for RingBufferWatchDelayInfoResponse {
8732        type Borrowed<'a> = &'a Self;
8733        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8734            value
8735        }
8736    }
8737
8738    unsafe impl fidl::encoding::TypeMarker for RingBufferWatchDelayInfoResponse {
8739        type Owned = Self;
8740
8741        #[inline(always)]
8742        fn inline_align(_context: fidl::encoding::Context) -> usize {
8743            8
8744        }
8745
8746        #[inline(always)]
8747        fn inline_size(_context: fidl::encoding::Context) -> usize {
8748            16
8749        }
8750    }
8751
8752    unsafe impl<D: fidl::encoding::ResourceDialect>
8753        fidl::encoding::Encode<RingBufferWatchDelayInfoResponse, D>
8754        for &RingBufferWatchDelayInfoResponse
8755    {
8756        unsafe fn encode(
8757            self,
8758            encoder: &mut fidl::encoding::Encoder<'_, D>,
8759            offset: usize,
8760            mut depth: fidl::encoding::Depth,
8761        ) -> fidl::Result<()> {
8762            encoder.debug_check_bounds::<RingBufferWatchDelayInfoResponse>(offset);
8763            // Vector header
8764            let max_ordinal: u64 = self.max_ordinal_present();
8765            encoder.write_num(max_ordinal, offset);
8766            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8767            // Calling encoder.out_of_line_offset(0) is not allowed.
8768            if max_ordinal == 0 {
8769                return Ok(());
8770            }
8771            depth.increment()?;
8772            let envelope_size = 8;
8773            let bytes_len = max_ordinal as usize * envelope_size;
8774            #[allow(unused_variables)]
8775            let offset = encoder.out_of_line_offset(bytes_len);
8776            let mut _prev_end_offset: usize = 0;
8777            if 1 > max_ordinal {
8778                return Ok(());
8779            }
8780
8781            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8782            // are envelope_size bytes.
8783            let cur_offset: usize = (1 - 1) * envelope_size;
8784
8785            // Zero reserved fields.
8786            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8787
8788            // Safety:
8789            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8790            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8791            //   envelope_size bytes, there is always sufficient room.
8792            fidl::encoding::encode_in_envelope_optional::<DelayInfo, D>(
8793                self.delay_info
8794                    .as_ref()
8795                    .map(<DelayInfo as fidl::encoding::ValueTypeMarker>::borrow),
8796                encoder,
8797                offset + cur_offset,
8798                depth,
8799            )?;
8800
8801            _prev_end_offset = cur_offset + envelope_size;
8802
8803            Ok(())
8804        }
8805    }
8806
8807    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8808        for RingBufferWatchDelayInfoResponse
8809    {
8810        #[inline(always)]
8811        fn new_empty() -> Self {
8812            Self::default()
8813        }
8814
8815        unsafe fn decode(
8816            &mut self,
8817            decoder: &mut fidl::encoding::Decoder<'_, D>,
8818            offset: usize,
8819            mut depth: fidl::encoding::Depth,
8820        ) -> fidl::Result<()> {
8821            decoder.debug_check_bounds::<Self>(offset);
8822            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8823                None => return Err(fidl::Error::NotNullable),
8824                Some(len) => len,
8825            };
8826            // Calling decoder.out_of_line_offset(0) is not allowed.
8827            if len == 0 {
8828                return Ok(());
8829            };
8830            depth.increment()?;
8831            let envelope_size = 8;
8832            let bytes_len = len * envelope_size;
8833            let offset = decoder.out_of_line_offset(bytes_len)?;
8834            // Decode the envelope for each type.
8835            let mut _next_ordinal_to_read = 0;
8836            let mut next_offset = offset;
8837            let end_offset = offset + bytes_len;
8838            _next_ordinal_to_read += 1;
8839            if next_offset >= end_offset {
8840                return Ok(());
8841            }
8842
8843            // Decode unknown envelopes for gaps in ordinals.
8844            while _next_ordinal_to_read < 1 {
8845                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8846                _next_ordinal_to_read += 1;
8847                next_offset += envelope_size;
8848            }
8849
8850            let next_out_of_line = decoder.next_out_of_line();
8851            let handles_before = decoder.remaining_handles();
8852            if let Some((inlined, num_bytes, num_handles)) =
8853                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8854            {
8855                let member_inline_size =
8856                    <DelayInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8857                if inlined != (member_inline_size <= 4) {
8858                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8859                }
8860                let inner_offset;
8861                let mut inner_depth = depth.clone();
8862                if inlined {
8863                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8864                    inner_offset = next_offset;
8865                } else {
8866                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8867                    inner_depth.increment()?;
8868                }
8869                let val_ref = self.delay_info.get_or_insert_with(|| fidl::new_empty!(DelayInfo, D));
8870                fidl::decode!(DelayInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
8871                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8872                {
8873                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8874                }
8875                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8876                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8877                }
8878            }
8879
8880            next_offset += envelope_size;
8881
8882            // Decode the remaining unknown envelopes.
8883            while next_offset < end_offset {
8884                _next_ordinal_to_read += 1;
8885                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8886                next_offset += envelope_size;
8887            }
8888
8889            Ok(())
8890        }
8891    }
8892}