fidl_fuchsia_bluetooth_sys__common/
fidl_fuchsia_bluetooth_sys__common.rs

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