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