fidl_fuchsia_bluetooth_bredr__common/
fidl_fuchsia_bluetooth_bredr__common.rs

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