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