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