fidl_fuchsia_bluetooth_le__common/
fidl_fuchsia_bluetooth_le__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/// An identifier for a service that accepts connection-oriented channel
12/// connections. Referred to as a (simplified) protocol/service multiplexer
13/// in the Bluetooth specification.
14pub type Psm = u16;
15
16pub const MAX_BROADCAST_NAME_OCTETS: u8 = 128;
17
18/// An ISO data packet can be no larger than the maximum 12-bit unsigned integer.
19/// See Bluetooth Core Spec Version 6.0 | Vol 4, Part E, Section 5.4.5
20pub const MAX_ISO_PACKET_SIZE: u16 = 4095;
21
22pub const MAX_MANUFACTURER_DATA_LENGTH: u8 = 252;
23
24pub const MAX_SERVICE_DATA_LENGTH: u8 = 252;
25
26/// The maximum number of connected isochronous streams that can be added to
27/// a connected isochronous group.
28pub const MAX_STREAMS_IN_GROUP: u8 = 31;
29
30pub const MAX_URI_LENGTH: u16 = 278;
31
32/// A client can indicate the transmission rate of advertising packets by specifying a mode. The
33/// mode provides a hint to the system when configuring the controller with advertising interval and
34/// window parameters.
35///
36/// The mode affects how quickly a scanner or central is able to discover the peripheral; however it
37/// can have an adverse effect on power consumption. While the system will try to honor a client's
38/// request, it is not guaranteed to do so.
39#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
40#[repr(u8)]
41pub enum AdvertisingModeHint {
42    /// Advertise with a very short interval and window for fast discovery at the cost of higher
43    /// power consumption. This corresponds to a 30-60ms interval on the 1M PHYs and 90-180ms on the
44    /// coded PHY.
45    VeryFast = 1,
46    /// Advertise with a short interval and window that uses less power than `VERY_FAST`.
47    /// This corresponds to a 100-150ms interval on the 1M PHYs and 300-450ms on the coded PHY.
48    Fast = 2,
49    /// Advertise with a moderate interval and window. This corresponds to 1-1.2s on the 1M PHYs and 3s
50    /// on the coded PHY.
51    Slow = 3,
52}
53
54impl AdvertisingModeHint {
55    #[inline]
56    pub fn from_primitive(prim: u8) -> Option<Self> {
57        match prim {
58            1 => Some(Self::VeryFast),
59            2 => Some(Self::Fast),
60            3 => Some(Self::Slow),
61            _ => None,
62        }
63    }
64
65    #[inline]
66    pub const fn into_primitive(self) -> u8 {
67        self as u8
68    }
69}
70
71#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
72#[repr(u32)]
73pub enum CentralError {
74    /// The request was aborted.
75    Aborted = 1,
76    /// The request is already in progress.
77    InProgress = 2,
78    /// The provided parameters are invalid.
79    InvalidParameters = 3,
80    /// Advertising could not be initiated due to a hardware or system error.
81    Failed = 4,
82}
83
84impl CentralError {
85    #[inline]
86    pub fn from_primitive(prim: u32) -> Option<Self> {
87        match prim {
88            1 => Some(Self::Aborted),
89            2 => Some(Self::InProgress),
90            3 => Some(Self::InvalidParameters),
91            4 => Some(Self::Failed),
92            _ => None,
93        }
94    }
95
96    #[inline]
97    pub const fn into_primitive(self) -> u32 {
98        self as u32
99    }
100}
101
102#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
103#[repr(u32)]
104pub enum CigFramingOptions {
105    Unframed = 0,
106    Framed = 1,
107}
108
109impl CigFramingOptions {
110    #[inline]
111    pub fn from_primitive(prim: u32) -> Option<Self> {
112        match prim {
113            0 => Some(Self::Unframed),
114            1 => Some(Self::Framed),
115            _ => None,
116        }
117    }
118
119    #[inline]
120    pub const fn into_primitive(self) -> u32 {
121        self as u32
122    }
123}
124
125#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
126pub enum CigPacking {
127    Sequential,
128    Interleaved,
129    #[doc(hidden)]
130    __SourceBreaking {
131        unknown_ordinal: u32,
132    },
133}
134
135/// Pattern that matches an unknown `CigPacking` member.
136#[macro_export]
137macro_rules! CigPackingUnknown {
138    () => {
139        _
140    };
141}
142
143impl CigPacking {
144    #[inline]
145    pub fn from_primitive(prim: u32) -> Option<Self> {
146        match prim {
147            0 => Some(Self::Sequential),
148            1 => Some(Self::Interleaved),
149            _ => None,
150        }
151    }
152
153    #[inline]
154    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
155        match prim {
156            0 => Self::Sequential,
157            1 => Self::Interleaved,
158            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
159        }
160    }
161
162    #[inline]
163    pub fn unknown() -> Self {
164        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
165    }
166
167    #[inline]
168    pub const fn into_primitive(self) -> u32 {
169        match self {
170            Self::Sequential => 0,
171            Self::Interleaved => 1,
172            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
173        }
174    }
175
176    #[inline]
177    pub fn is_unknown(&self) -> bool {
178        match self {
179            Self::__SourceBreaking { unknown_ordinal: _ } => true,
180            _ => false,
181        }
182    }
183}
184
185#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
186pub enum CreateCigError {
187    /// The CIG could not be created because an unknown or unspecified error occurred unrelated
188    /// to the other errors defined below.
189    Unknown,
190    /// The CIG could not be created because it would exceed available resources.
191    NotEnoughResources,
192    /// The CIG could not be created because the combination of parameters supplied to CreateCig
193    /// for one or more CISes are invalid.
194    InvalidCisParameters,
195    #[doc(hidden)]
196    __SourceBreaking { unknown_ordinal: u32 },
197}
198
199/// Pattern that matches an unknown `CreateCigError` member.
200#[macro_export]
201macro_rules! CreateCigErrorUnknown {
202    () => {
203        _
204    };
205}
206
207impl CreateCigError {
208    #[inline]
209    pub fn from_primitive(prim: u32) -> Option<Self> {
210        match prim {
211            1 => Some(Self::Unknown),
212            2 => Some(Self::NotEnoughResources),
213            3 => Some(Self::InvalidCisParameters),
214            _ => None,
215        }
216    }
217
218    #[inline]
219    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
220        match prim {
221            1 => Self::Unknown,
222            2 => Self::NotEnoughResources,
223            3 => Self::InvalidCisParameters,
224            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
225        }
226    }
227
228    #[inline]
229    pub fn unknown() -> Self {
230        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
231    }
232
233    #[inline]
234    pub const fn into_primitive(self) -> u32 {
235        match self {
236            Self::Unknown => 1,
237            Self::NotEnoughResources => 2,
238            Self::InvalidCisParameters => 3,
239            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
240        }
241    }
242
243    #[inline]
244    pub fn is_unknown(&self) -> bool {
245        match self {
246            Self::__SourceBreaking { unknown_ordinal: _ } => true,
247            _ => false,
248        }
249    }
250}
251
252#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
253pub enum EstablishStreamsError {
254    /// The controller does not support a CIS with the parameters specified for it.
255    NotSupported,
256    /// The same CIS was specified multiple times in a call.
257    DuplicateCis,
258    /// One or more CISes specified already exist.
259    CisAlreadyEstablished,
260    /// One or more of the peers specified in the CIS parameters are not connected.
261    PeerNotConnected,
262    #[doc(hidden)]
263    __SourceBreaking { unknown_ordinal: u32 },
264}
265
266/// Pattern that matches an unknown `EstablishStreamsError` member.
267#[macro_export]
268macro_rules! EstablishStreamsErrorUnknown {
269    () => {
270        _
271    };
272}
273
274impl EstablishStreamsError {
275    #[inline]
276    pub fn from_primitive(prim: u32) -> Option<Self> {
277        match prim {
278            1 => Some(Self::NotSupported),
279            2 => Some(Self::DuplicateCis),
280            3 => Some(Self::CisAlreadyEstablished),
281            4 => Some(Self::PeerNotConnected),
282            _ => None,
283        }
284    }
285
286    #[inline]
287    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
288        match prim {
289            1 => Self::NotSupported,
290            2 => Self::DuplicateCis,
291            3 => Self::CisAlreadyEstablished,
292            4 => Self::PeerNotConnected,
293            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
294        }
295    }
296
297    #[inline]
298    pub fn unknown() -> Self {
299        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
300    }
301
302    #[inline]
303    pub const fn into_primitive(self) -> u32 {
304        match self {
305            Self::NotSupported => 1,
306            Self::DuplicateCis => 2,
307            Self::CisAlreadyEstablished => 3,
308            Self::PeerNotConnected => 4,
309            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
310        }
311    }
312
313    #[inline]
314    pub fn is_unknown(&self) -> bool {
315        match self {
316            Self::__SourceBreaking { unknown_ordinal: _ } => true,
317            _ => false,
318        }
319    }
320}
321
322/// Flags indicating validity of data received from an isochronous channel.
323#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
324#[repr(u8)]
325pub enum IsoPacketStatusFlag {
326    /// Valid data. The complete SDU was received correctly.
327    ValidData = 0,
328    /// Possibly invalid data. One ore more of the fragments received may contain errors or part of
329    /// the packet may be missing.
330    DataWithPossibleErrors = 1,
331    /// Parts of the packet were not received correctly.
332    LostData = 2,
333}
334
335impl IsoPacketStatusFlag {
336    #[inline]
337    pub fn from_primitive(prim: u8) -> Option<Self> {
338        match prim {
339            0 => Some(Self::ValidData),
340            1 => Some(Self::DataWithPossibleErrors),
341            2 => Some(Self::LostData),
342            _ => None,
343        }
344    }
345
346    #[inline]
347    pub const fn into_primitive(self) -> u8 {
348        self as u8
349    }
350}
351
352#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
353#[repr(u32)]
354pub enum PeripheralError {
355    /// The operation or parameters requested are not supported on the current hardware.
356    NotSupported = 1,
357    /// The provided advertising data exceeds the maximum allowed length when encoded.
358    AdvertisingDataTooLong = 2,
359    /// The provided scan response data exceeds the maximum allowed length when encoded.
360    ScanResponseDataTooLong = 3,
361    /// The requested parameters are invalid.
362    InvalidParameters = 4,
363    /// The request to start advertising was aborted, for example by issuing a new request with new
364    /// parameters.
365    Aborted = 5,
366    /// Advertising could not be initiated due to a hardware or system error.
367    Failed = 6,
368}
369
370impl PeripheralError {
371    #[inline]
372    pub fn from_primitive(prim: u32) -> Option<Self> {
373        match prim {
374            1 => Some(Self::NotSupported),
375            2 => Some(Self::AdvertisingDataTooLong),
376            3 => Some(Self::ScanResponseDataTooLong),
377            4 => Some(Self::InvalidParameters),
378            5 => Some(Self::Aborted),
379            6 => Some(Self::Failed),
380            _ => None,
381        }
382    }
383
384    #[inline]
385    pub const fn into_primitive(self) -> u32 {
386        self as u32
387    }
388}
389
390/// Represents advertising and scan response data advertised by a broadcaster or peripheral.
391#[derive(Clone, Debug, PartialEq)]
392pub struct AdvertisingDataDeprecated {
393    /// Name of the device.
394    pub name: Option<String>,
395    /// The radio transmission power level reported in the advertisement.
396    pub tx_power_level: Option<Box<fidl_fuchsia_bluetooth__common::Int8>>,
397    /// The appearance reported in the advertisemet.
398    pub appearance: Option<Box<fidl_fuchsia_bluetooth__common::UInt16>>,
399    /// List of service UUIDs reported in the advertisement.
400    pub service_uuids: Option<Vec<String>>,
401    /// Service data included in the advertisement.
402    pub service_data: Option<Vec<ServiceDataEntry>>,
403    /// Manufacturer specific data entries.
404    pub manufacturer_specific_data: Option<Vec<ManufacturerSpecificDataEntry>>,
405    /// Service UUIDs that were solicited in the advertisement. Peripherals can invite centrals that
406    /// expose certain services to connect to them using service solicitation.
407    pub solicited_service_uuids: Option<Vec<String>>,
408    /// URIs included in the advertising packet.
409    /// These are full URIs (they are encoded/decoded automatically)
410    pub uris: Option<Vec<String>>,
411}
412
413impl fidl::Persistable for AdvertisingDataDeprecated {}
414
415#[derive(Clone, Debug, PartialEq)]
416pub struct CentralConnectPeripheralResponse {
417    pub status: fidl_fuchsia_bluetooth__common::Status,
418}
419
420impl fidl::Persistable for CentralConnectPeripheralResponse {}
421
422#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
423pub struct CentralDisconnectPeripheralRequest {
424    pub identifier: String,
425}
426
427impl fidl::Persistable for CentralDisconnectPeripheralRequest {}
428
429#[derive(Clone, Debug, PartialEq)]
430pub struct CentralDisconnectPeripheralResponse {
431    pub status: fidl_fuchsia_bluetooth__common::Status,
432}
433
434impl fidl::Persistable for CentralDisconnectPeripheralResponse {}
435
436#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
437pub struct CentralGetPeripheralRequest {
438    pub identifier: String,
439}
440
441impl fidl::Persistable for CentralGetPeripheralRequest {}
442
443#[derive(Clone, Debug, PartialEq)]
444pub struct CentralGetPeripheralResponse {
445    pub peripheral: Option<Box<RemoteDevice>>,
446}
447
448impl fidl::Persistable for CentralGetPeripheralResponse {}
449
450#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
451pub struct CentralGetPeripheralsRequest {
452    pub service_uuids: Option<Vec<String>>,
453}
454
455impl fidl::Persistable for CentralGetPeripheralsRequest {}
456
457#[derive(Clone, Debug, PartialEq)]
458pub struct CentralGetPeripheralsResponse {
459    pub peripherals: Vec<RemoteDevice>,
460}
461
462impl fidl::Persistable for CentralGetPeripheralsResponse {}
463
464#[derive(Clone, Debug, PartialEq)]
465pub struct CentralOnDeviceDiscoveredRequest {
466    pub device: RemoteDevice,
467}
468
469impl fidl::Persistable for CentralOnDeviceDiscoveredRequest {}
470
471#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
472pub struct CentralOnPeripheralDisconnectedRequest {
473    pub identifier: String,
474}
475
476impl fidl::Persistable for CentralOnPeripheralDisconnectedRequest {}
477
478#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
479pub struct CentralOnScanStateChangedRequest {
480    pub scanning: bool,
481}
482
483impl fidl::Persistable for CentralOnScanStateChangedRequest {}
484
485#[derive(Clone, Debug, PartialEq)]
486pub struct CentralStartScanRequest {
487    pub filter: Option<Box<ScanFilter>>,
488}
489
490impl fidl::Persistable for CentralStartScanRequest {}
491
492#[derive(Clone, Debug, PartialEq)]
493pub struct CentralStartScanResponse {
494    pub status: fidl_fuchsia_bluetooth__common::Status,
495}
496
497impl fidl::Persistable for CentralStartScanResponse {}
498
499/// Entry in the `manufacturer_data` field of a [`fuchsia.bluetooth.le/AdvertisingData`].
500#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
501pub struct ManufacturerData {
502    pub company_id: u16,
503    pub data: Vec<u8>,
504}
505
506impl fidl::Persistable for ManufacturerData {}
507
508#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
509pub struct ManufacturerSpecificDataEntry {
510    pub company_id: u16,
511    pub data: Vec<u8>,
512}
513
514impl fidl::Persistable for ManufacturerSpecificDataEntry {}
515
516/// Represents a remote Bluetooth Low Energy device. A RemoteDevice can represent a central,
517/// broadcaster, or peripheral based on the API from which it was received.
518#[derive(Clone, Debug, PartialEq)]
519pub struct RemoteDevice {
520    /// Identifier that uniquely identifies this device on the current system.
521    pub identifier: String,
522    /// Whether or not this device is connectable. Non-connectable devices are typically acting in the
523    /// LE broadcaster role.
524    pub connectable: bool,
525    /// The last known RSSI of this device, if known.
526    pub rssi: Option<Box<fidl_fuchsia_bluetooth__common::Int8>>,
527    /// Advertising data broadcast by this device if this device is a broadcaster or peripheral.
528    pub advertising_data: Option<Box<AdvertisingDataDeprecated>>,
529}
530
531impl fidl::Persistable for RemoteDevice {}
532
533/// Filter parameters for use during a scan. A discovered peripheral or broadcaster will be reported
534/// to applications only if it satisfies all of the provided filter parameters. Null fields will be
535/// ignored.
536#[derive(Clone, Debug, PartialEq)]
537pub struct ScanFilter {
538    /// Filter based on advertised service UUIDs. A peripheral that advertises at least one of the
539    /// entries in `service_uuids` will satisfy this filter.
540    pub service_uuids: Option<Vec<String>>,
541    /// Filter based on service data containing one of the given UUIDs.
542    pub service_data_uuids: Option<Vec<String>>,
543    /// Filter based on a company identifier present in the manufacturer data. If this filter parameter
544    /// is set, then the advertising payload must contain manufacturer specific data with the provided
545    /// company identifier to satisfy this filter.
546    pub manufacturer_identifier: Option<Box<fidl_fuchsia_bluetooth__common::UInt16>>,
547    /// Filter based on whether or not a device is connectable. For example, a client that is only
548    /// interested in peripherals that it can connect to can set this to true. Similarly a client can
549    /// scan only for braodcasters by setting this to false.
550    pub connectable: Option<Box<fidl_fuchsia_bluetooth__common::Bool>>,
551    /// Filter results based on a portion of the advertised device name.
552    pub name_substring: Option<String>,
553    /// Filter results based on the path loss of the radio wave. A device that matches this filter must
554    /// satisfy the following:
555    ///   1. Radio transmission power level and received signal strength must be available for the path
556    ///      loss calculation;
557    ///   2. The calculated path loss value must be less than, or equal to, `max_path_loss`.
558    pub max_path_loss: Option<Box<fidl_fuchsia_bluetooth__common::Int8>>,
559}
560
561impl fidl::Persistable for ScanFilter {}
562
563#[derive(Clone, Debug, PartialEq)]
564pub struct ScanResultWatcherWatchResponse {
565    pub updated: Vec<Peer>,
566}
567
568impl fidl::Persistable for ScanResultWatcherWatchResponse {}
569
570/// Entry in the `service_data` field of a [`fuchsia.bluetooth.le/AdvertisingData`].
571#[derive(Clone, Debug, PartialEq)]
572pub struct ServiceData {
573    pub uuid: fidl_fuchsia_bluetooth__common::Uuid,
574    pub data: Vec<u8>,
575}
576
577impl fidl::Persistable for ServiceData {}
578
579#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
580pub struct ServiceDataEntry {
581    pub uuid: String,
582    pub data: Vec<u8>,
583}
584
585impl fidl::Persistable for ServiceDataEntry {}
586
587/// The set of parameters for accepting a channel when listening for new channel
588/// connections.
589///
590/// See [`ChannelListenerRegistry/ListenL2cap`].
591#[derive(Clone, Debug, Default, PartialEq)]
592pub struct AcceptedChannelParameters {
593    /// All channel modes that should be accepted while listening. Must contain
594    /// at least one channel mode or the call will fail with
595    /// `ZX_ERR_INVALID_ARGS`.
596    /// Required.
597    pub accepted_channel_modes: Option<Vec<fidl_fuchsia_bluetooth__common::ChannelMode>>,
598    /// Maximum supported packet size for receiving.
599    /// Optional. If not provided, the size will be determined by the Bluetooth
600    /// system. No guarantees are given regarding the size selected.
601    pub max_packet_size: Option<u16>,
602    #[doc(hidden)]
603    pub __source_breaking: fidl::marker::SourceBreaking,
604}
605
606impl fidl::Persistable for AcceptedChannelParameters {}
607
608/// Represents advertising and scan response data that are transmitted by a LE peripheral or
609/// broadcaster.
610#[derive(Clone, Debug, Default, PartialEq)]
611pub struct AdvertisingData {
612    /// Long or short name of the device.
613    pub name: Option<String>,
614    /// The appearance of the device.
615    pub appearance: Option<fidl_fuchsia_bluetooth__common::Appearance>,
616    pub tx_power_level: Option<i8>,
617    /// Service UUIDs.
618    pub service_uuids: Option<Vec<fidl_fuchsia_bluetooth__common::Uuid>>,
619    /// Service data entries.
620    pub service_data: Option<Vec<ServiceData>>,
621    /// Manufacturer-specific data entries.
622    pub manufacturer_data: Option<Vec<ManufacturerData>>,
623    /// String representing a URI to be advertised, as defined in [IETF STD 66](https://tools.ietf.org/html/std66).
624    /// Each entry should be a UTF-8 string including the scheme. For more information, see:
625    /// - https://www.iana.org/assignments/uri-schemes/uri-schemes.xhtml for allowed schemes;
626    /// - https://www.bluetooth.com/specifications/assigned-numbers/uri-scheme-name-string-mapping
627    ///   for code-points used by the system to compress the scheme to save space in the payload.
628    pub uris: Option<Vec<String>>,
629    /// Indicates whether the current TX power level should be included in the advertising data.
630    pub include_tx_power_level: Option<bool>,
631    /// Identifies the peer as belonging to a Coordinated Set.
632    /// Resolution and generation of this parameter is defined in the
633    /// Coordinated Set Identification Service Specification.
634    pub resolvable_set_identifier: Option<[u8; 6]>,
635    /// The broadcast name string can be used by a user interface on a scanning
636    /// device that displays information on the available broadcast sources.
637    ///
638    /// Multiple devices with the same Broadcast Name may be transmitting the
639    /// same data, allowing devices to choose one.  At least 4 unicode characters
640    /// long and no more than 32 characters.
641    ///
642    /// Defined in the Public Broadcast Profile specification.
643    pub broadcast_name: Option<String>,
644    #[doc(hidden)]
645    pub __source_breaking: fidl::marker::SourceBreaking,
646}
647
648impl fidl::Persistable for AdvertisingData {}
649
650/// Represents the parameters for configuring advertisements.
651#[derive(Clone, Debug, Default, PartialEq)]
652pub struct AdvertisingParameters {
653    /// The fields that will be encoded in the data section of advertising packets.
654    ///
655    /// This field is required.
656    pub data: Option<AdvertisingData>,
657    /// The fields that are to be sent in a scan response packet. Clients may use this to send
658    /// additional data that does not fit inside an advertising packet on platforms that do not
659    /// support the advertising data length extensions.
660    ///
661    /// If present advertisements will be configured to be scannable.
662    pub scan_response: Option<AdvertisingData>,
663    /// The desired advertising frequency. See [`fuchsia.bluetooth.le/AdvertisingModeHint`].
664    /// Defaults to [`fuchsia.bluetooth.le/AdvertisingModeHint.SLOW`] if not present.
665    pub mode_hint: Option<AdvertisingModeHint>,
666    /// If present and true then the controller will broadcast connectable advertisements which
667    /// allows remote LE centrals to initiate a connection to the Peripheral. If false or otherwise
668    /// not present then the advertisements will be non-connectable.
669    pub connectable: Option<bool>,
670    /// If present, the controller will broadcast connectable advertisements
671    /// which allow peers to initiate connections to the Peripheral. The fields
672    /// of `ConnectionOptions` will configure any connections set up from
673    /// advertising.
674    pub connection_options: Option<ConnectionOptions>,
675    /// Specifies the advertising type to use (e.g. legacy, extended, etc).
676    ///
677    /// If not present, we default to legacy advertising to maintain optimal compatibility with
678    /// pre-Bluetooth 5.0 devices. See field descriptions within AdvertisingProcedure for more
679    /// information.
680    pub advertising_procedure: Option<AdvertisingProcedure>,
681    /// If privacy is not enabled, the address type will always be public.
682    ///
683    /// If privacy is enabled and the client is not privileged, the address will be a random
684    /// private address (either resolvable or non-resolvable). A non-privileged client requesting a
685    /// public address will return an error.
686    ///
687    /// If privacy is enabled and the client is privileged, they may request any address type,
688    /// or will default to a random private address.
689    ///
690    /// If this field is unset, the address type will be public or random depending on if privacy
691    /// is enabled in the system.
692    pub address_type: Option<fidl_fuchsia_bluetooth__common::AddressType>,
693    #[doc(hidden)]
694    pub __source_breaking: fidl::marker::SourceBreaking,
695}
696
697impl fidl::Persistable for AdvertisingParameters {}
698
699#[derive(Clone, Debug, Default, PartialEq)]
700pub struct CentralCreateConnectedIsochronousGroupResponse {
701    /// A unique CIG_ID, allocated by the host.
702    pub cig_id: Option<u8>,
703    #[doc(hidden)]
704    pub __source_breaking: fidl::marker::SourceBreaking,
705}
706
707impl fidl::Persistable for CentralCreateConnectedIsochronousGroupResponse {}
708
709#[derive(Clone, Debug, Default, PartialEq)]
710pub struct ChannelListenerRegistryListenL2capResponse {
711    /// PSM assigned by the registry. Guaranteed to be in the `DYNAMIC`
712    /// range of PSM values.
713    pub psm: Option<u16>,
714    #[doc(hidden)]
715    pub __source_breaking: fidl::marker::SourceBreaking,
716}
717
718impl fidl::Persistable for ChannelListenerRegistryListenL2capResponse {}
719
720#[derive(Clone, Debug, Default, PartialEq)]
721pub struct CigParameters {
722    /// Interval between the start of consecutive SDUs (central => peripheral,
723    /// microseconds). This is a function of the codec being used.
724    /// Required.
725    pub sdu_interval_c_to_p: Option<u32>,
726    /// Interval between the start of consecutive SDUs (peripheral => central,
727    /// microseconds). This is a function of the codec being used.
728    /// Required.
729    pub sdu_interval_p_to_c: Option<u32>,
730    /// The preferred method of arranging subevents of multiple CISes. The
731    /// controller may ignore this parameter.
732    /// Optional. If not specified, SEQUENTIAL will be used.
733    pub packing: Option<CigPacking>,
734    /// Specifies inclusion of time offset values in data frame.
735    /// Optional. If not specified, UNFRAMED will be used.
736    pub framing: Option<CigFramingOptions>,
737    /// Maximum latency, in milliseconds, between controllers (central =>
738    /// peripheral).
739    /// Required.
740    pub max_transport_latency_c_to_p: Option<u16>,
741    /// Maximum latency, in milliseconds, between controllers (peripheral =>
742    /// central).
743    /// Required.
744    pub max_transport_latency_p_to_c: Option<u16>,
745    #[doc(hidden)]
746    pub __source_breaking: fidl::marker::SourceBreaking,
747}
748
749impl fidl::Persistable for CigParameters {}
750
751/// Established configuration for a single CIS.
752#[derive(Clone, Debug, Default, PartialEq)]
753pub struct CisEstablishedParameters {
754    /// Maximum time for transmission of PDUs of all CISes in a CIG event.
755    /// In the range [234, 8388607] microseconds.
756    ///
757    /// This field is always present.
758    pub cig_sync_delay: Option<i64>,
759    /// The maximum time for transmission of PDUs of the specified CIS in a CIG
760    /// event. In the range [234, 8388607] microseconds.
761    ///
762    /// This field is always present.
763    pub cis_sync_delay: Option<i64>,
764    /// Maximum number of subevents in each CIS event.
765    ///
766    /// This field is always present.
767    pub max_subevents: Option<u8>,
768    /// Time between two consecutive CIS anchor points, in the range [5ms, 4s]
769    ///
770    /// This field is always present.
771    pub iso_interval: Option<i64>,
772    /// Parameters for Central => Peripheral transmissions, if applicable.
773    ///
774    /// This field is present if the stream includes isochronous data transmission from the
775    /// Central to the Peripheral.
776    pub central_to_peripheral_params: Option<CisUnidirectionalParams>,
777    /// Parameters for Peripheral => Central transmissions, if applicable.
778    ///
779    /// This field is present if the stream includes isochronous data transmission from the
780    /// Peripheral to the Central.
781    pub peripheral_to_central_params: Option<CisUnidirectionalParams>,
782    #[doc(hidden)]
783    pub __source_breaking: fidl::marker::SourceBreaking,
784}
785
786impl fidl::Persistable for CisEstablishedParameters {}
787
788#[derive(Clone, Debug, Default, PartialEq)]
789pub struct CisParameters {
790    /// ID of the stream to establish (as previously passed to Connection/CreateCig()).
791    /// Required.
792    pub cis_id: Option<u8>,
793    /// Peripheral device providing other end of the isochronous data stream.
794    /// Required.
795    pub id: Option<fidl_fuchsia_bluetooth__common::PeerId>,
796    #[doc(hidden)]
797    pub __source_breaking: fidl::marker::SourceBreaking,
798}
799
800impl fidl::Persistable for CisParameters {}
801
802/// Parameters related to a single direction of transmission in an established CIS.
803#[derive(Clone, Debug, Default, PartialEq)]
804pub struct CisUnidirectionalParams {
805    /// Transport latency, in the range [234, 8388607] microseconds
806    ///
807    /// This field is always present.
808    pub transport_latency: Option<i64>,
809    /// Burst number for transmissions in this direction.
810    ///
811    /// This field is always present.
812    pub burst_number: Option<u8>,
813    /// Flush timeout for each payload, in multiples of the ISO interval.
814    ///
815    /// This field is always present.
816    pub flush_timeout: Option<u8>,
817    #[doc(hidden)]
818    pub __source_breaking: fidl::marker::SourceBreaking,
819}
820
821impl fidl::Persistable for CisUnidirectionalParams {}
822
823#[derive(Clone, Debug, Default, PartialEq)]
824pub struct CodecDelayGetCodecLocalDelayRangeRequest {
825    /// Logical transport type being used. Currenly only supports LE transport mechanisms
826    /// (CIS or BIS). Required.
827    pub logical_transport_type: Option<fidl_fuchsia_bluetooth__common::LogicalTransportType>,
828    /// Indicates direction of data flow. Required.
829    pub data_direction: Option<fidl_fuchsia_bluetooth__common::DataDirection>,
830    /// Codec being used over the air. Required.
831    pub codec_attributes: Option<fidl_fuchsia_bluetooth__common::CodecAttributes>,
832    #[doc(hidden)]
833    pub __source_breaking: fidl::marker::SourceBreaking,
834}
835
836impl fidl::Persistable for CodecDelayGetCodecLocalDelayRangeRequest {}
837
838#[derive(Clone, Debug, Default, PartialEq)]
839pub struct CodecDelayGetCodecLocalDelayRangeResponse {
840    /// Minimum controller delay for the specified configuration, in the range [0, 4] seconds.
841    /// Always provided on success.
842    pub min_controller_delay: Option<i64>,
843    /// Maximum controller delay for the specified configuration, in the range [0, 4] seconds.
844    /// Always provided on success.
845    pub max_controller_delay: Option<i64>,
846    #[doc(hidden)]
847    pub __source_breaking: fidl::marker::SourceBreaking,
848}
849
850impl fidl::Persistable for CodecDelayGetCodecLocalDelayRangeResponse {}
851
852#[derive(Clone, Debug, Default, PartialEq)]
853pub struct ConnectedIsochronousGroupEstablishStreamsRequest {
854    /// Required.
855    pub cis_params: Option<Vec<CisParameters>>,
856    #[doc(hidden)]
857    pub __source_breaking: fidl::marker::SourceBreaking,
858}
859
860impl fidl::Persistable for ConnectedIsochronousGroupEstablishStreamsRequest {}
861
862/// Represents parameters that are set on a per-connection basis by FIDL protocols that create
863/// Low Energy connections.
864#[derive(Clone, Debug, Default, PartialEq)]
865pub struct ConnectionOptions {
866    /// When true, the connection operates in bondable mode. This means pairing will form a bond,
867    /// or persist across disconnections, if the peer is also in bondable mode. When not present,
868    /// the connection defaults to bondable mode. When false, the connection operates in non-
869    /// bondable mode, which means the local device only allows pairing that does not form a bond.
870    pub bondable_mode: Option<bool>,
871    /// When present, service discovery performed following the connection is restricted to primary
872    /// services that match this field. Otherwise, by default all available services are discovered.
873    pub service_filter: Option<fidl_fuchsia_bluetooth__common::Uuid>,
874    #[doc(hidden)]
875    pub __source_breaking: fidl::marker::SourceBreaking,
876}
877
878impl fidl::Persistable for ConnectionOptions {}
879
880#[derive(Clone, Debug, Default, PartialEq)]
881pub struct Extended {
882    #[doc(hidden)]
883    pub __source_breaking: fidl::marker::SourceBreaking,
884}
885
886impl fidl::Persistable for Extended {}
887
888/// Filter parameters for use during a scan. A discovered peer only matches the
889/// filter if it satisfies all of the present filter parameters.
890#[derive(Clone, Debug, Default, PartialEq)]
891pub struct Filter {
892    /// Filter based on advertised service UUID.
893    pub service_uuid: Option<fidl_fuchsia_bluetooth__common::Uuid>,
894    /// Filter based on service data containing the given UUID.
895    pub service_data_uuid: Option<fidl_fuchsia_bluetooth__common::Uuid>,
896    /// Filter based on a manufacturer identifier present in the manufacturer
897    /// data. If this filter parameter is set, then the advertising payload must
898    /// contain manufacturer specific data with the provided company identifier
899    /// to satisfy this filter. Manufacturer identifiers can be found at
900    /// https://www.bluetooth.com/specifications/assigned-numbers/company-identifiers/
901    pub manufacturer_id: Option<u16>,
902    /// Filter based on whether or not a device is connectable. For example, a
903    /// client that is only interested in peripherals that it can connect to can
904    /// set this to true. Similarly a client can scan only for broadcasters by
905    /// setting this to false.
906    pub connectable: Option<bool>,
907    /// Filter results based on a portion of the advertised device name.
908    /// Substring matches are allowed.
909    pub name: Option<String>,
910    /// Filter results based on the path loss of the radio wave. A device that
911    /// matches this filter must satisfy the following:
912    ///   1. Radio transmission power level and received signal strength must be
913    ///      available for the path loss calculation;
914    ///   2. The calculated path loss value must be less than, or equal to,
915    ///      `max_path_loss`.
916    ///
917    /// NOTE: This field is calculated using the RSSI and TX Power information
918    /// obtained from advertising and scan response data during a scan procedure.
919    /// It should NOT be confused with information for an active connection
920    /// obtained using the "Path Loss Reporting" feature.
921    pub max_path_loss: Option<i8>,
922    /// Filter based on a service solicitation by service UUID.
923    /// Service solicitation is an invitation to a peer to connect if they
924    /// provide a service we want to use.
925    pub solicitation_uuid: Option<fidl_fuchsia_bluetooth__common::Uuid>,
926    #[doc(hidden)]
927    pub __source_breaking: fidl::marker::SourceBreaking,
928}
929
930impl fidl::Persistable for Filter {}
931
932#[derive(Clone, Debug, Default, PartialEq)]
933pub struct IsochronousStreamOnEstablishedRequest {
934    /// A result of ZX_ERR_INTERNAL indicates that the controller received a request
935    /// but was unable to establish the stream.
936    pub result: Option<i32>,
937    /// This field is always present if a stream was successfully established.
938    pub established_params: Option<CisEstablishedParameters>,
939    #[doc(hidden)]
940    pub __source_breaking: fidl::marker::SourceBreaking,
941}
942
943impl fidl::Persistable for IsochronousStreamOnEstablishedRequest {}
944
945#[derive(Clone, Debug, Default, PartialEq)]
946pub struct IsochronousStreamSetupDataPathRequest {
947    /// Directions in which data will flow.
948    /// Required.
949    pub data_direction: Option<fidl_fuchsia_bluetooth__common::DataDirection>,
950    /// Specifies the coding format used over the air.
951    /// Required.
952    pub codec_attributes: Option<fidl_fuchsia_bluetooth__common::CodecAttributes>,
953    /// The delay provided must be within the controller's supported range and should not
954    /// exceed 4 seconds.
955    /// Required.
956    pub controller_delay: Option<i64>,
957    #[doc(hidden)]
958    pub __source_breaking: fidl::marker::SourceBreaking,
959}
960
961impl fidl::Persistable for IsochronousStreamSetupDataPathRequest {}
962
963#[derive(Clone, Debug, Default, PartialEq)]
964pub struct IsochronousStreamWriteRequest {
965    /// The data frame itself.
966    pub data: Option<Vec<u8>>,
967    #[doc(hidden)]
968    pub __source_breaking: fidl::marker::SourceBreaking,
969}
970
971impl fidl::Persistable for IsochronousStreamWriteRequest {}
972
973#[derive(Clone, Debug, Default, PartialEq)]
974pub struct IsochronousStreamReadResponse {
975    /// The data frame itself.
976    /// Required.
977    pub data: Option<Vec<u8>>,
978    /// The sequence number associated with the frame.
979    /// Required.
980    pub sequence_number: Option<u16>,
981    /// Status flags of packet, as reported by the controller.
982    /// Required.
983    pub status_flag: Option<IsoPacketStatusFlag>,
984    /// Reception timestamp, as reported by the controller.
985    /// Optional.
986    pub timestamp: Option<i64>,
987    #[doc(hidden)]
988    pub __source_breaking: fidl::marker::SourceBreaking,
989}
990
991impl fidl::Persistable for IsochronousStreamReadResponse {}
992
993#[derive(Clone, Debug, Default, PartialEq)]
994pub struct Legacy {
995    #[doc(hidden)]
996    pub __source_breaking: fidl::marker::SourceBreaking,
997}
998
999impl fidl::Persistable for Legacy {}
1000
1001/// Represents a Bluetooth Low Energy peer that may act in the broadcaster, peripheral, or central
1002/// role. The peer's role depends on whether it is obtained from the Central or Peripheral protocol.
1003#[derive(Clone, Debug, Default, PartialEq)]
1004pub struct Peer {
1005    /// Uniquely identifies this peer on the current system.
1006    ///
1007    /// This field is always present.
1008    pub id: Option<fidl_fuchsia_bluetooth__common::PeerId>,
1009    /// Whether or not this peer is connectable. Non-connectable peers are typically in the LE
1010    /// broadcaster role.
1011    ///
1012    /// This field is always present.
1013    pub connectable: Option<bool>,
1014    /// The last observed signal strength of this peer. This field is only present for a peer that
1015    /// is broadcasting. The RSSI can be stale if the peer has not been advertising.
1016    ///
1017    /// NOTE: This field should NOT be confused with the "connection RSSI" of a peer that is currently
1018    /// connected to the system.
1019    pub rssi: Option<i8>,
1020    pub advertising_data: Option<AdvertisingData>,
1021    /// The name of this peer. The name is often obtained during a scan procedure and can get
1022    /// updated during the name discovery procedure following a connection.
1023    ///
1024    /// This field is present if the name is known.
1025    pub name: Option<String>,
1026    /// Information from advertising and scan response data broadcast by this peer. When present,
1027    /// this contains the advertising data last received from the peer.
1028    pub data: Option<ScanData>,
1029    /// Whether or not this peer is bonded.
1030    ///
1031    /// This field is always present.
1032    pub bonded: Option<bool>,
1033    /// The value of the system monotonic clock, measured at the time this peer
1034    /// was last updated (e.g. due to reception of an advertisement).
1035    ///
1036    /// This field is always present.
1037    pub last_updated: Option<i64>,
1038    /// Value of the Advertising SID.
1039    ///
1040    /// Range: 0x00 to 0x0F
1041    pub advertising_sid: Option<u8>,
1042    /// Interval of the periodic advertising.
1043    ///
1044    /// Range: 0x0006 to 0xFFFF
1045    pub periodic_advertising_interval: Option<u16>,
1046    #[doc(hidden)]
1047    pub __source_breaking: fidl::marker::SourceBreaking,
1048}
1049
1050impl fidl::Persistable for Peer {}
1051
1052/// Information obtained from advertising and scan response data broadcast by a peer.
1053#[derive(Clone, Debug, Default, PartialEq)]
1054pub struct ScanData {
1055    /// The radio transmit power level reported by an advertising and/or scannable peer.
1056    ///
1057    /// NOTE: This field should NOT be confused with the "connection TX Power Level" of a peer that
1058    /// is currently connected to the system obtained via the "Transmit Power reporting" feature.
1059    pub tx_power: Option<i8>,
1060    /// The appearance of the device.
1061    pub appearance: Option<fidl_fuchsia_bluetooth__common::Appearance>,
1062    /// Service UUIDs.
1063    pub service_uuids: Option<Vec<fidl_fuchsia_bluetooth__common::Uuid>>,
1064    /// Service data entries.
1065    pub service_data: Option<Vec<ServiceData>>,
1066    /// Manufacturer-specific data entries.
1067    pub manufacturer_data: Option<Vec<ManufacturerData>>,
1068    /// String representing a URI to be advertised, as defined in [IETF STD 66](https://tools.ietf.org/html/std66).
1069    /// Each entry should be a UTF-8 string including the scheme. For more information, see
1070    /// https://www.iana.org/assignments/uri-schemes/uri-schemes.xhtml for allowed schemes;
1071    /// NOTE: Bluetooth advertising compresses schemas over the air to save space. See
1072    /// https://www.bluetooth.com/specifications/assigned-numbers/uri-scheme-name-string-mapping.
1073    pub uris: Option<Vec<String>>,
1074    /// The monotonic time when this scan data was received.
1075    pub timestamp: Option<i64>,
1076    #[doc(hidden)]
1077    pub __source_breaking: fidl::marker::SourceBreaking,
1078}
1079
1080impl fidl::Persistable for ScanData {}
1081
1082/// Parameters used during a scan.
1083#[derive(Clone, Debug, Default, PartialEq)]
1084pub struct ScanOptions {
1085    /// List of filters for use during a scan. A peripheral that satisfies any
1086    /// of these filters will be reported. At least 1 filter must be specified.
1087    /// While not recommended, clients that require that all peripherals be
1088    /// reported can specify an empty filter.
1089    pub filters: Option<Vec<Filter>>,
1090    #[doc(hidden)]
1091    pub __source_breaking: fidl::marker::SourceBreaking,
1092}
1093
1094impl fidl::Persistable for ScanOptions {}
1095
1096#[derive(Clone, Debug)]
1097pub enum AdvertisingProcedure {
1098    /// Advertise using legacy advertising packets. All devices should be able
1099    /// to discover this type of packet.
1100    Legacy(Legacy),
1101    /// Advertise using extended advertising packets. Extended advertising
1102    /// packets allow for a much larger amount of data to be advertised than
1103    /// legacy advertising packets (31 bytes vs 251 bytes per PDU). Extended
1104    /// advertising packets support up to 1,650 bytes in an advertisement chain,
1105    /// but they are only discoverable by newer devices using Bluetooth 5.0+.
1106    ///
1107    /// Extended advertising packets are not supported by all
1108    /// products. PeripheralError::NOT_SUPPORTED will be returned if requested
1109    /// and not supported.
1110    Extended(Extended),
1111    #[doc(hidden)]
1112    __SourceBreaking { unknown_ordinal: u64 },
1113}
1114
1115/// Pattern that matches an unknown `AdvertisingProcedure` member.
1116#[macro_export]
1117macro_rules! AdvertisingProcedureUnknown {
1118    () => {
1119        _
1120    };
1121}
1122
1123// Custom PartialEq so that unknown variants are not equal to themselves.
1124impl PartialEq for AdvertisingProcedure {
1125    fn eq(&self, other: &Self) -> bool {
1126        match (self, other) {
1127            (Self::Legacy(x), Self::Legacy(y)) => *x == *y,
1128            (Self::Extended(x), Self::Extended(y)) => *x == *y,
1129            _ => false,
1130        }
1131    }
1132}
1133
1134impl AdvertisingProcedure {
1135    #[inline]
1136    pub fn ordinal(&self) -> u64 {
1137        match *self {
1138            Self::Legacy(_) => 1,
1139            Self::Extended(_) => 2,
1140            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1141        }
1142    }
1143
1144    #[inline]
1145    pub fn unknown_variant_for_testing() -> Self {
1146        Self::__SourceBreaking { unknown_ordinal: 0 }
1147    }
1148
1149    #[inline]
1150    pub fn is_unknown(&self) -> bool {
1151        match self {
1152            Self::__SourceBreaking { .. } => true,
1153            _ => false,
1154        }
1155    }
1156}
1157
1158impl fidl::Persistable for AdvertisingProcedure {}
1159
1160pub mod advertised_peripheral_ordinals {
1161    pub const ON_CONNECTED: u64 = 0x607b7716457eb178;
1162}
1163
1164pub mod advertising_handle_ordinals {}
1165
1166pub mod central_ordinals {
1167    pub const LISTEN_L2CAP: u64 = 0x39c6e9001d102338;
1168    pub const SCAN: u64 = 0x41f7121798dfe15f;
1169    pub const CONNECT: u64 = 0x31a3065f2a6913c4;
1170    pub const CREATE_CONNECTED_ISOCHRONOUS_GROUP: u64 = 0x60323e70ae22e13;
1171    pub const GET_PERIPHERALS: u64 = 0x37ba777499c683a8;
1172    pub const GET_PERIPHERAL: u64 = 0x97f5a2f2d9c13da;
1173    pub const START_SCAN: u64 = 0xeb4cf0cd0e1132b;
1174    pub const STOP_SCAN: u64 = 0x5f79ee6a0bb037a0;
1175    pub const CONNECT_PERIPHERAL: u64 = 0x714d6c32d066d75a;
1176    pub const DISCONNECT_PERIPHERAL: u64 = 0xa9430da197362fd;
1177    pub const ON_SCAN_STATE_CHANGED: u64 = 0x5f8edc23cad04d3f;
1178    pub const ON_DEVICE_DISCOVERED: u64 = 0x708dadf20d66db6;
1179    pub const ON_PERIPHERAL_DISCONNECTED: u64 = 0x4e4c6b979b2126df;
1180}
1181
1182pub mod channel_listener_ordinals {
1183    pub const ACCEPT: u64 = 0x6f535bd36b20fc7b;
1184}
1185
1186pub mod channel_listener_registry_ordinals {
1187    pub const LISTEN_L2CAP: u64 = 0x39c6e9001d102338;
1188}
1189
1190pub mod codec_delay_ordinals {
1191    pub const GET_CODEC_LOCAL_DELAY_RANGE: u64 = 0x1cf34fdeed80b4d;
1192}
1193
1194pub mod connected_isochronous_group_ordinals {
1195    pub const ESTABLISH_STREAMS: u64 = 0xc7296c5edb4dacc;
1196    pub const REMOVE: u64 = 0xbed433babd20503;
1197}
1198
1199pub mod connection_ordinals {
1200    pub const GET_CODEC_LOCAL_DELAY_RANGE: u64 = 0x1cf34fdeed80b4d;
1201    pub const REQUEST_GATT_CLIENT: u64 = 0x2a670e0fec6ccc6b;
1202    pub const ACCEPT_CIS: u64 = 0x7e6338c237088144;
1203    pub const CONNECT_L2CAP: u64 = 0x12351316feaebce9;
1204}
1205
1206pub mod isochronous_stream_ordinals {
1207    pub const ON_ESTABLISHED: u64 = 0x341c50e9d10f3421;
1208    pub const SETUP_DATA_PATH: u64 = 0x7ec1e2b9cc6d2fbe;
1209    pub const READ: u64 = 0x6d7d8b4950ed3a32;
1210    pub const WRITE: u64 = 0x5282e90b667d0d43;
1211}
1212
1213pub mod peripheral_ordinals {
1214    pub const LISTEN_L2CAP: u64 = 0x39c6e9001d102338;
1215    pub const ADVERTISE: u64 = 0x2d9ec9260c32c17f;
1216    pub const START_ADVERTISING: u64 = 0x5875c1c575f00f7d;
1217    pub const ON_PEER_CONNECTED: u64 = 0x16135d464299e356;
1218}
1219
1220pub mod privileged_peripheral_ordinals {
1221    pub const LISTEN_L2CAP: u64 = 0x39c6e9001d102338;
1222    pub const ADVERTISE: u64 = 0x2d9ec9260c32c17f;
1223    pub const START_ADVERTISING: u64 = 0x5875c1c575f00f7d;
1224    pub const ON_PEER_CONNECTED: u64 = 0x16135d464299e356;
1225}
1226
1227pub mod scan_result_watcher_ordinals {
1228    pub const WATCH: u64 = 0x713a122e949f301a;
1229}
1230
1231mod internal {
1232    use super::*;
1233    unsafe impl fidl::encoding::TypeMarker for AdvertisingModeHint {
1234        type Owned = Self;
1235
1236        #[inline(always)]
1237        fn inline_align(_context: fidl::encoding::Context) -> usize {
1238            std::mem::align_of::<u8>()
1239        }
1240
1241        #[inline(always)]
1242        fn inline_size(_context: fidl::encoding::Context) -> usize {
1243            std::mem::size_of::<u8>()
1244        }
1245
1246        #[inline(always)]
1247        fn encode_is_copy() -> bool {
1248            true
1249        }
1250
1251        #[inline(always)]
1252        fn decode_is_copy() -> bool {
1253            false
1254        }
1255    }
1256
1257    impl fidl::encoding::ValueTypeMarker for AdvertisingModeHint {
1258        type Borrowed<'a> = Self;
1259        #[inline(always)]
1260        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1261            *value
1262        }
1263    }
1264
1265    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1266        for AdvertisingModeHint
1267    {
1268        #[inline]
1269        unsafe fn encode(
1270            self,
1271            encoder: &mut fidl::encoding::Encoder<'_, D>,
1272            offset: usize,
1273            _depth: fidl::encoding::Depth,
1274        ) -> fidl::Result<()> {
1275            encoder.debug_check_bounds::<Self>(offset);
1276            encoder.write_num(self.into_primitive(), offset);
1277            Ok(())
1278        }
1279    }
1280
1281    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvertisingModeHint {
1282        #[inline(always)]
1283        fn new_empty() -> Self {
1284            Self::VeryFast
1285        }
1286
1287        #[inline]
1288        unsafe fn decode(
1289            &mut self,
1290            decoder: &mut fidl::encoding::Decoder<'_, D>,
1291            offset: usize,
1292            _depth: fidl::encoding::Depth,
1293        ) -> fidl::Result<()> {
1294            decoder.debug_check_bounds::<Self>(offset);
1295            let prim = decoder.read_num::<u8>(offset);
1296
1297            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1298            Ok(())
1299        }
1300    }
1301    unsafe impl fidl::encoding::TypeMarker for CentralError {
1302        type Owned = Self;
1303
1304        #[inline(always)]
1305        fn inline_align(_context: fidl::encoding::Context) -> usize {
1306            std::mem::align_of::<u32>()
1307        }
1308
1309        #[inline(always)]
1310        fn inline_size(_context: fidl::encoding::Context) -> usize {
1311            std::mem::size_of::<u32>()
1312        }
1313
1314        #[inline(always)]
1315        fn encode_is_copy() -> bool {
1316            true
1317        }
1318
1319        #[inline(always)]
1320        fn decode_is_copy() -> bool {
1321            false
1322        }
1323    }
1324
1325    impl fidl::encoding::ValueTypeMarker for CentralError {
1326        type Borrowed<'a> = Self;
1327        #[inline(always)]
1328        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1329            *value
1330        }
1331    }
1332
1333    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CentralError {
1334        #[inline]
1335        unsafe fn encode(
1336            self,
1337            encoder: &mut fidl::encoding::Encoder<'_, D>,
1338            offset: usize,
1339            _depth: fidl::encoding::Depth,
1340        ) -> fidl::Result<()> {
1341            encoder.debug_check_bounds::<Self>(offset);
1342            encoder.write_num(self.into_primitive(), offset);
1343            Ok(())
1344        }
1345    }
1346
1347    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CentralError {
1348        #[inline(always)]
1349        fn new_empty() -> Self {
1350            Self::Aborted
1351        }
1352
1353        #[inline]
1354        unsafe fn decode(
1355            &mut self,
1356            decoder: &mut fidl::encoding::Decoder<'_, D>,
1357            offset: usize,
1358            _depth: fidl::encoding::Depth,
1359        ) -> fidl::Result<()> {
1360            decoder.debug_check_bounds::<Self>(offset);
1361            let prim = decoder.read_num::<u32>(offset);
1362
1363            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1364            Ok(())
1365        }
1366    }
1367    unsafe impl fidl::encoding::TypeMarker for CigFramingOptions {
1368        type Owned = Self;
1369
1370        #[inline(always)]
1371        fn inline_align(_context: fidl::encoding::Context) -> usize {
1372            std::mem::align_of::<u32>()
1373        }
1374
1375        #[inline(always)]
1376        fn inline_size(_context: fidl::encoding::Context) -> usize {
1377            std::mem::size_of::<u32>()
1378        }
1379
1380        #[inline(always)]
1381        fn encode_is_copy() -> bool {
1382            true
1383        }
1384
1385        #[inline(always)]
1386        fn decode_is_copy() -> bool {
1387            false
1388        }
1389    }
1390
1391    impl fidl::encoding::ValueTypeMarker for CigFramingOptions {
1392        type Borrowed<'a> = Self;
1393        #[inline(always)]
1394        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1395            *value
1396        }
1397    }
1398
1399    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1400        for CigFramingOptions
1401    {
1402        #[inline]
1403        unsafe fn encode(
1404            self,
1405            encoder: &mut fidl::encoding::Encoder<'_, D>,
1406            offset: usize,
1407            _depth: fidl::encoding::Depth,
1408        ) -> fidl::Result<()> {
1409            encoder.debug_check_bounds::<Self>(offset);
1410            encoder.write_num(self.into_primitive(), offset);
1411            Ok(())
1412        }
1413    }
1414
1415    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CigFramingOptions {
1416        #[inline(always)]
1417        fn new_empty() -> Self {
1418            Self::Unframed
1419        }
1420
1421        #[inline]
1422        unsafe fn decode(
1423            &mut self,
1424            decoder: &mut fidl::encoding::Decoder<'_, D>,
1425            offset: usize,
1426            _depth: fidl::encoding::Depth,
1427        ) -> fidl::Result<()> {
1428            decoder.debug_check_bounds::<Self>(offset);
1429            let prim = decoder.read_num::<u32>(offset);
1430
1431            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1432            Ok(())
1433        }
1434    }
1435    unsafe impl fidl::encoding::TypeMarker for CigPacking {
1436        type Owned = Self;
1437
1438        #[inline(always)]
1439        fn inline_align(_context: fidl::encoding::Context) -> usize {
1440            std::mem::align_of::<u32>()
1441        }
1442
1443        #[inline(always)]
1444        fn inline_size(_context: fidl::encoding::Context) -> usize {
1445            std::mem::size_of::<u32>()
1446        }
1447
1448        #[inline(always)]
1449        fn encode_is_copy() -> bool {
1450            false
1451        }
1452
1453        #[inline(always)]
1454        fn decode_is_copy() -> bool {
1455            false
1456        }
1457    }
1458
1459    impl fidl::encoding::ValueTypeMarker for CigPacking {
1460        type Borrowed<'a> = Self;
1461        #[inline(always)]
1462        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1463            *value
1464        }
1465    }
1466
1467    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CigPacking {
1468        #[inline]
1469        unsafe fn encode(
1470            self,
1471            encoder: &mut fidl::encoding::Encoder<'_, D>,
1472            offset: usize,
1473            _depth: fidl::encoding::Depth,
1474        ) -> fidl::Result<()> {
1475            encoder.debug_check_bounds::<Self>(offset);
1476            encoder.write_num(self.into_primitive(), offset);
1477            Ok(())
1478        }
1479    }
1480
1481    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CigPacking {
1482        #[inline(always)]
1483        fn new_empty() -> Self {
1484            Self::unknown()
1485        }
1486
1487        #[inline]
1488        unsafe fn decode(
1489            &mut self,
1490            decoder: &mut fidl::encoding::Decoder<'_, D>,
1491            offset: usize,
1492            _depth: fidl::encoding::Depth,
1493        ) -> fidl::Result<()> {
1494            decoder.debug_check_bounds::<Self>(offset);
1495            let prim = decoder.read_num::<u32>(offset);
1496
1497            *self = Self::from_primitive_allow_unknown(prim);
1498            Ok(())
1499        }
1500    }
1501    unsafe impl fidl::encoding::TypeMarker for CreateCigError {
1502        type Owned = Self;
1503
1504        #[inline(always)]
1505        fn inline_align(_context: fidl::encoding::Context) -> usize {
1506            std::mem::align_of::<u32>()
1507        }
1508
1509        #[inline(always)]
1510        fn inline_size(_context: fidl::encoding::Context) -> usize {
1511            std::mem::size_of::<u32>()
1512        }
1513
1514        #[inline(always)]
1515        fn encode_is_copy() -> bool {
1516            false
1517        }
1518
1519        #[inline(always)]
1520        fn decode_is_copy() -> bool {
1521            false
1522        }
1523    }
1524
1525    impl fidl::encoding::ValueTypeMarker for CreateCigError {
1526        type Borrowed<'a> = Self;
1527        #[inline(always)]
1528        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1529            *value
1530        }
1531    }
1532
1533    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CreateCigError {
1534        #[inline]
1535        unsafe fn encode(
1536            self,
1537            encoder: &mut fidl::encoding::Encoder<'_, D>,
1538            offset: usize,
1539            _depth: fidl::encoding::Depth,
1540        ) -> fidl::Result<()> {
1541            encoder.debug_check_bounds::<Self>(offset);
1542            encoder.write_num(self.into_primitive(), offset);
1543            Ok(())
1544        }
1545    }
1546
1547    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CreateCigError {
1548        #[inline(always)]
1549        fn new_empty() -> Self {
1550            Self::unknown()
1551        }
1552
1553        #[inline]
1554        unsafe fn decode(
1555            &mut self,
1556            decoder: &mut fidl::encoding::Decoder<'_, D>,
1557            offset: usize,
1558            _depth: fidl::encoding::Depth,
1559        ) -> fidl::Result<()> {
1560            decoder.debug_check_bounds::<Self>(offset);
1561            let prim = decoder.read_num::<u32>(offset);
1562
1563            *self = Self::from_primitive_allow_unknown(prim);
1564            Ok(())
1565        }
1566    }
1567    unsafe impl fidl::encoding::TypeMarker for EstablishStreamsError {
1568        type Owned = Self;
1569
1570        #[inline(always)]
1571        fn inline_align(_context: fidl::encoding::Context) -> usize {
1572            std::mem::align_of::<u32>()
1573        }
1574
1575        #[inline(always)]
1576        fn inline_size(_context: fidl::encoding::Context) -> usize {
1577            std::mem::size_of::<u32>()
1578        }
1579
1580        #[inline(always)]
1581        fn encode_is_copy() -> bool {
1582            false
1583        }
1584
1585        #[inline(always)]
1586        fn decode_is_copy() -> bool {
1587            false
1588        }
1589    }
1590
1591    impl fidl::encoding::ValueTypeMarker for EstablishStreamsError {
1592        type Borrowed<'a> = Self;
1593        #[inline(always)]
1594        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1595            *value
1596        }
1597    }
1598
1599    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1600        for EstablishStreamsError
1601    {
1602        #[inline]
1603        unsafe fn encode(
1604            self,
1605            encoder: &mut fidl::encoding::Encoder<'_, D>,
1606            offset: usize,
1607            _depth: fidl::encoding::Depth,
1608        ) -> fidl::Result<()> {
1609            encoder.debug_check_bounds::<Self>(offset);
1610            encoder.write_num(self.into_primitive(), offset);
1611            Ok(())
1612        }
1613    }
1614
1615    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EstablishStreamsError {
1616        #[inline(always)]
1617        fn new_empty() -> Self {
1618            Self::unknown()
1619        }
1620
1621        #[inline]
1622        unsafe fn decode(
1623            &mut self,
1624            decoder: &mut fidl::encoding::Decoder<'_, D>,
1625            offset: usize,
1626            _depth: fidl::encoding::Depth,
1627        ) -> fidl::Result<()> {
1628            decoder.debug_check_bounds::<Self>(offset);
1629            let prim = decoder.read_num::<u32>(offset);
1630
1631            *self = Self::from_primitive_allow_unknown(prim);
1632            Ok(())
1633        }
1634    }
1635    unsafe impl fidl::encoding::TypeMarker for IsoPacketStatusFlag {
1636        type Owned = Self;
1637
1638        #[inline(always)]
1639        fn inline_align(_context: fidl::encoding::Context) -> usize {
1640            std::mem::align_of::<u8>()
1641        }
1642
1643        #[inline(always)]
1644        fn inline_size(_context: fidl::encoding::Context) -> usize {
1645            std::mem::size_of::<u8>()
1646        }
1647
1648        #[inline(always)]
1649        fn encode_is_copy() -> bool {
1650            true
1651        }
1652
1653        #[inline(always)]
1654        fn decode_is_copy() -> bool {
1655            false
1656        }
1657    }
1658
1659    impl fidl::encoding::ValueTypeMarker for IsoPacketStatusFlag {
1660        type Borrowed<'a> = Self;
1661        #[inline(always)]
1662        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1663            *value
1664        }
1665    }
1666
1667    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1668        for IsoPacketStatusFlag
1669    {
1670        #[inline]
1671        unsafe fn encode(
1672            self,
1673            encoder: &mut fidl::encoding::Encoder<'_, D>,
1674            offset: usize,
1675            _depth: fidl::encoding::Depth,
1676        ) -> fidl::Result<()> {
1677            encoder.debug_check_bounds::<Self>(offset);
1678            encoder.write_num(self.into_primitive(), offset);
1679            Ok(())
1680        }
1681    }
1682
1683    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IsoPacketStatusFlag {
1684        #[inline(always)]
1685        fn new_empty() -> Self {
1686            Self::ValidData
1687        }
1688
1689        #[inline]
1690        unsafe fn decode(
1691            &mut self,
1692            decoder: &mut fidl::encoding::Decoder<'_, D>,
1693            offset: usize,
1694            _depth: fidl::encoding::Depth,
1695        ) -> fidl::Result<()> {
1696            decoder.debug_check_bounds::<Self>(offset);
1697            let prim = decoder.read_num::<u8>(offset);
1698
1699            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1700            Ok(())
1701        }
1702    }
1703    unsafe impl fidl::encoding::TypeMarker for PeripheralError {
1704        type Owned = Self;
1705
1706        #[inline(always)]
1707        fn inline_align(_context: fidl::encoding::Context) -> usize {
1708            std::mem::align_of::<u32>()
1709        }
1710
1711        #[inline(always)]
1712        fn inline_size(_context: fidl::encoding::Context) -> usize {
1713            std::mem::size_of::<u32>()
1714        }
1715
1716        #[inline(always)]
1717        fn encode_is_copy() -> bool {
1718            true
1719        }
1720
1721        #[inline(always)]
1722        fn decode_is_copy() -> bool {
1723            false
1724        }
1725    }
1726
1727    impl fidl::encoding::ValueTypeMarker for PeripheralError {
1728        type Borrowed<'a> = Self;
1729        #[inline(always)]
1730        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1731            *value
1732        }
1733    }
1734
1735    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1736        for PeripheralError
1737    {
1738        #[inline]
1739        unsafe fn encode(
1740            self,
1741            encoder: &mut fidl::encoding::Encoder<'_, D>,
1742            offset: usize,
1743            _depth: fidl::encoding::Depth,
1744        ) -> fidl::Result<()> {
1745            encoder.debug_check_bounds::<Self>(offset);
1746            encoder.write_num(self.into_primitive(), offset);
1747            Ok(())
1748        }
1749    }
1750
1751    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PeripheralError {
1752        #[inline(always)]
1753        fn new_empty() -> Self {
1754            Self::NotSupported
1755        }
1756
1757        #[inline]
1758        unsafe fn decode(
1759            &mut self,
1760            decoder: &mut fidl::encoding::Decoder<'_, D>,
1761            offset: usize,
1762            _depth: fidl::encoding::Depth,
1763        ) -> fidl::Result<()> {
1764            decoder.debug_check_bounds::<Self>(offset);
1765            let prim = decoder.read_num::<u32>(offset);
1766
1767            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1768            Ok(())
1769        }
1770    }
1771
1772    impl fidl::encoding::ValueTypeMarker for AdvertisingDataDeprecated {
1773        type Borrowed<'a> = &'a Self;
1774        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1775            value
1776        }
1777    }
1778
1779    unsafe impl fidl::encoding::TypeMarker for AdvertisingDataDeprecated {
1780        type Owned = Self;
1781
1782        #[inline(always)]
1783        fn inline_align(_context: fidl::encoding::Context) -> usize {
1784            8
1785        }
1786
1787        #[inline(always)]
1788        fn inline_size(_context: fidl::encoding::Context) -> usize {
1789            112
1790        }
1791    }
1792
1793    unsafe impl<D: fidl::encoding::ResourceDialect>
1794        fidl::encoding::Encode<AdvertisingDataDeprecated, D> for &AdvertisingDataDeprecated
1795    {
1796        #[inline]
1797        unsafe fn encode(
1798            self,
1799            encoder: &mut fidl::encoding::Encoder<'_, D>,
1800            offset: usize,
1801            _depth: fidl::encoding::Depth,
1802        ) -> fidl::Result<()> {
1803            encoder.debug_check_bounds::<AdvertisingDataDeprecated>(offset);
1804            // Delegate to tuple encoding.
1805            fidl::encoding::Encode::<AdvertisingDataDeprecated, D>::encode(
1806                (
1807                    <fidl::encoding::Optional<fidl::encoding::BoundedString<248>> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
1808                    <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8> as fidl::encoding::ValueTypeMarker>::borrow(&self.tx_power_level),
1809                    <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16> as fidl::encoding::ValueTypeMarker>::borrow(&self.appearance),
1810                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.service_uuids),
1811                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<ServiceDataEntry>> as fidl::encoding::ValueTypeMarker>::borrow(&self.service_data),
1812                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<ManufacturerSpecificDataEntry>> as fidl::encoding::ValueTypeMarker>::borrow(&self.manufacturer_specific_data),
1813                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.solicited_service_uuids),
1814                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>> as fidl::encoding::ValueTypeMarker>::borrow(&self.uris),
1815                ),
1816                encoder, offset, _depth
1817            )
1818        }
1819    }
1820    unsafe impl<
1821            D: fidl::encoding::ResourceDialect,
1822            T0: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<248>>, D>,
1823            T1: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>, D>,
1824            T2: fidl::encoding::Encode<
1825                fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
1826                D,
1827            >,
1828            T3: fidl::encoding::Encode<
1829                fidl::encoding::Optional<
1830                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1831                >,
1832                D,
1833            >,
1834            T4: fidl::encoding::Encode<
1835                fidl::encoding::Optional<fidl::encoding::UnboundedVector<ServiceDataEntry>>,
1836                D,
1837            >,
1838            T5: fidl::encoding::Encode<
1839                fidl::encoding::Optional<
1840                    fidl::encoding::UnboundedVector<ManufacturerSpecificDataEntry>,
1841                >,
1842                D,
1843            >,
1844            T6: fidl::encoding::Encode<
1845                fidl::encoding::Optional<
1846                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1847                >,
1848                D,
1849            >,
1850            T7: fidl::encoding::Encode<
1851                fidl::encoding::Optional<
1852                    fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
1853                >,
1854                D,
1855            >,
1856        > fidl::encoding::Encode<AdvertisingDataDeprecated, D>
1857        for (T0, T1, T2, T3, T4, T5, T6, T7)
1858    {
1859        #[inline]
1860        unsafe fn encode(
1861            self,
1862            encoder: &mut fidl::encoding::Encoder<'_, D>,
1863            offset: usize,
1864            depth: fidl::encoding::Depth,
1865        ) -> fidl::Result<()> {
1866            encoder.debug_check_bounds::<AdvertisingDataDeprecated>(offset);
1867            // Zero out padding regions. There's no need to apply masks
1868            // because the unmasked parts will be overwritten by fields.
1869            // Write the fields.
1870            self.0.encode(encoder, offset + 0, depth)?;
1871            self.1.encode(encoder, offset + 16, depth)?;
1872            self.2.encode(encoder, offset + 24, depth)?;
1873            self.3.encode(encoder, offset + 32, depth)?;
1874            self.4.encode(encoder, offset + 48, depth)?;
1875            self.5.encode(encoder, offset + 64, depth)?;
1876            self.6.encode(encoder, offset + 80, depth)?;
1877            self.7.encode(encoder, offset + 96, depth)?;
1878            Ok(())
1879        }
1880    }
1881
1882    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1883        for AdvertisingDataDeprecated
1884    {
1885        #[inline(always)]
1886        fn new_empty() -> Self {
1887            Self {
1888                name: fidl::new_empty!(
1889                    fidl::encoding::Optional<fidl::encoding::BoundedString<248>>,
1890                    D
1891                ),
1892                tx_power_level: fidl::new_empty!(
1893                    fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
1894                    D
1895                ),
1896                appearance: fidl::new_empty!(
1897                    fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
1898                    D
1899                ),
1900                service_uuids: fidl::new_empty!(
1901                    fidl::encoding::Optional<
1902                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1903                    >,
1904                    D
1905                ),
1906                service_data: fidl::new_empty!(
1907                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<ServiceDataEntry>>,
1908                    D
1909                ),
1910                manufacturer_specific_data: fidl::new_empty!(
1911                    fidl::encoding::Optional<
1912                        fidl::encoding::UnboundedVector<ManufacturerSpecificDataEntry>,
1913                    >,
1914                    D
1915                ),
1916                solicited_service_uuids: fidl::new_empty!(
1917                    fidl::encoding::Optional<
1918                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1919                    >,
1920                    D
1921                ),
1922                uris: fidl::new_empty!(
1923                    fidl::encoding::Optional<
1924                        fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
1925                    >,
1926                    D
1927                ),
1928            }
1929        }
1930
1931        #[inline]
1932        unsafe fn decode(
1933            &mut self,
1934            decoder: &mut fidl::encoding::Decoder<'_, D>,
1935            offset: usize,
1936            _depth: fidl::encoding::Depth,
1937        ) -> fidl::Result<()> {
1938            decoder.debug_check_bounds::<Self>(offset);
1939            // Verify that padding bytes are zero.
1940            fidl::decode!(
1941                fidl::encoding::Optional<fidl::encoding::BoundedString<248>>,
1942                D,
1943                &mut self.name,
1944                decoder,
1945                offset + 0,
1946                _depth
1947            )?;
1948            fidl::decode!(
1949                fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
1950                D,
1951                &mut self.tx_power_level,
1952                decoder,
1953                offset + 16,
1954                _depth
1955            )?;
1956            fidl::decode!(
1957                fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
1958                D,
1959                &mut self.appearance,
1960                decoder,
1961                offset + 24,
1962                _depth
1963            )?;
1964            fidl::decode!(
1965                fidl::encoding::Optional<
1966                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1967                >,
1968                D,
1969                &mut self.service_uuids,
1970                decoder,
1971                offset + 32,
1972                _depth
1973            )?;
1974            fidl::decode!(
1975                fidl::encoding::Optional<fidl::encoding::UnboundedVector<ServiceDataEntry>>,
1976                D,
1977                &mut self.service_data,
1978                decoder,
1979                offset + 48,
1980                _depth
1981            )?;
1982            fidl::decode!(
1983                fidl::encoding::Optional<
1984                    fidl::encoding::UnboundedVector<ManufacturerSpecificDataEntry>,
1985                >,
1986                D,
1987                &mut self.manufacturer_specific_data,
1988                decoder,
1989                offset + 64,
1990                _depth
1991            )?;
1992            fidl::decode!(
1993                fidl::encoding::Optional<
1994                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1995                >,
1996                D,
1997                &mut self.solicited_service_uuids,
1998                decoder,
1999                offset + 80,
2000                _depth
2001            )?;
2002            fidl::decode!(
2003                fidl::encoding::Optional<
2004                    fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
2005                >,
2006                D,
2007                &mut self.uris,
2008                decoder,
2009                offset + 96,
2010                _depth
2011            )?;
2012            Ok(())
2013        }
2014    }
2015
2016    impl fidl::encoding::ValueTypeMarker for CentralConnectPeripheralResponse {
2017        type Borrowed<'a> = &'a Self;
2018        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2019            value
2020        }
2021    }
2022
2023    unsafe impl fidl::encoding::TypeMarker for CentralConnectPeripheralResponse {
2024        type Owned = Self;
2025
2026        #[inline(always)]
2027        fn inline_align(_context: fidl::encoding::Context) -> usize {
2028            8
2029        }
2030
2031        #[inline(always)]
2032        fn inline_size(_context: fidl::encoding::Context) -> usize {
2033            8
2034        }
2035    }
2036
2037    unsafe impl<D: fidl::encoding::ResourceDialect>
2038        fidl::encoding::Encode<CentralConnectPeripheralResponse, D>
2039        for &CentralConnectPeripheralResponse
2040    {
2041        #[inline]
2042        unsafe fn encode(
2043            self,
2044            encoder: &mut fidl::encoding::Encoder<'_, D>,
2045            offset: usize,
2046            _depth: fidl::encoding::Depth,
2047        ) -> fidl::Result<()> {
2048            encoder.debug_check_bounds::<CentralConnectPeripheralResponse>(offset);
2049            // Delegate to tuple encoding.
2050            fidl::encoding::Encode::<CentralConnectPeripheralResponse, D>::encode(
2051                (
2052                    <fidl_fuchsia_bluetooth__common::Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
2053                ),
2054                encoder, offset, _depth
2055            )
2056        }
2057    }
2058    unsafe impl<
2059            D: fidl::encoding::ResourceDialect,
2060            T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::Status, D>,
2061        > fidl::encoding::Encode<CentralConnectPeripheralResponse, D> for (T0,)
2062    {
2063        #[inline]
2064        unsafe fn encode(
2065            self,
2066            encoder: &mut fidl::encoding::Encoder<'_, D>,
2067            offset: usize,
2068            depth: fidl::encoding::Depth,
2069        ) -> fidl::Result<()> {
2070            encoder.debug_check_bounds::<CentralConnectPeripheralResponse>(offset);
2071            // Zero out padding regions. There's no need to apply masks
2072            // because the unmasked parts will be overwritten by fields.
2073            // Write the fields.
2074            self.0.encode(encoder, offset + 0, depth)?;
2075            Ok(())
2076        }
2077    }
2078
2079    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2080        for CentralConnectPeripheralResponse
2081    {
2082        #[inline(always)]
2083        fn new_empty() -> Self {
2084            Self { status: fidl::new_empty!(fidl_fuchsia_bluetooth__common::Status, D) }
2085        }
2086
2087        #[inline]
2088        unsafe fn decode(
2089            &mut self,
2090            decoder: &mut fidl::encoding::Decoder<'_, D>,
2091            offset: usize,
2092            _depth: fidl::encoding::Depth,
2093        ) -> fidl::Result<()> {
2094            decoder.debug_check_bounds::<Self>(offset);
2095            // Verify that padding bytes are zero.
2096            fidl::decode!(
2097                fidl_fuchsia_bluetooth__common::Status,
2098                D,
2099                &mut self.status,
2100                decoder,
2101                offset + 0,
2102                _depth
2103            )?;
2104            Ok(())
2105        }
2106    }
2107
2108    impl fidl::encoding::ValueTypeMarker for CentralDisconnectPeripheralRequest {
2109        type Borrowed<'a> = &'a Self;
2110        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2111            value
2112        }
2113    }
2114
2115    unsafe impl fidl::encoding::TypeMarker for CentralDisconnectPeripheralRequest {
2116        type Owned = Self;
2117
2118        #[inline(always)]
2119        fn inline_align(_context: fidl::encoding::Context) -> usize {
2120            8
2121        }
2122
2123        #[inline(always)]
2124        fn inline_size(_context: fidl::encoding::Context) -> usize {
2125            16
2126        }
2127    }
2128
2129    unsafe impl<D: fidl::encoding::ResourceDialect>
2130        fidl::encoding::Encode<CentralDisconnectPeripheralRequest, D>
2131        for &CentralDisconnectPeripheralRequest
2132    {
2133        #[inline]
2134        unsafe fn encode(
2135            self,
2136            encoder: &mut fidl::encoding::Encoder<'_, D>,
2137            offset: usize,
2138            _depth: fidl::encoding::Depth,
2139        ) -> fidl::Result<()> {
2140            encoder.debug_check_bounds::<CentralDisconnectPeripheralRequest>(offset);
2141            // Delegate to tuple encoding.
2142            fidl::encoding::Encode::<CentralDisconnectPeripheralRequest, D>::encode(
2143                (<fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow(
2144                    &self.identifier,
2145                ),),
2146                encoder,
2147                offset,
2148                _depth,
2149            )
2150        }
2151    }
2152    unsafe impl<
2153            D: fidl::encoding::ResourceDialect,
2154            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<16>, D>,
2155        > fidl::encoding::Encode<CentralDisconnectPeripheralRequest, D> for (T0,)
2156    {
2157        #[inline]
2158        unsafe fn encode(
2159            self,
2160            encoder: &mut fidl::encoding::Encoder<'_, D>,
2161            offset: usize,
2162            depth: fidl::encoding::Depth,
2163        ) -> fidl::Result<()> {
2164            encoder.debug_check_bounds::<CentralDisconnectPeripheralRequest>(offset);
2165            // Zero out padding regions. There's no need to apply masks
2166            // because the unmasked parts will be overwritten by fields.
2167            // Write the fields.
2168            self.0.encode(encoder, offset + 0, depth)?;
2169            Ok(())
2170        }
2171    }
2172
2173    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2174        for CentralDisconnectPeripheralRequest
2175    {
2176        #[inline(always)]
2177        fn new_empty() -> Self {
2178            Self { identifier: fidl::new_empty!(fidl::encoding::BoundedString<16>, D) }
2179        }
2180
2181        #[inline]
2182        unsafe fn decode(
2183            &mut self,
2184            decoder: &mut fidl::encoding::Decoder<'_, D>,
2185            offset: usize,
2186            _depth: fidl::encoding::Depth,
2187        ) -> fidl::Result<()> {
2188            decoder.debug_check_bounds::<Self>(offset);
2189            // Verify that padding bytes are zero.
2190            fidl::decode!(
2191                fidl::encoding::BoundedString<16>,
2192                D,
2193                &mut self.identifier,
2194                decoder,
2195                offset + 0,
2196                _depth
2197            )?;
2198            Ok(())
2199        }
2200    }
2201
2202    impl fidl::encoding::ValueTypeMarker for CentralDisconnectPeripheralResponse {
2203        type Borrowed<'a> = &'a Self;
2204        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2205            value
2206        }
2207    }
2208
2209    unsafe impl fidl::encoding::TypeMarker for CentralDisconnectPeripheralResponse {
2210        type Owned = Self;
2211
2212        #[inline(always)]
2213        fn inline_align(_context: fidl::encoding::Context) -> usize {
2214            8
2215        }
2216
2217        #[inline(always)]
2218        fn inline_size(_context: fidl::encoding::Context) -> usize {
2219            8
2220        }
2221    }
2222
2223    unsafe impl<D: fidl::encoding::ResourceDialect>
2224        fidl::encoding::Encode<CentralDisconnectPeripheralResponse, D>
2225        for &CentralDisconnectPeripheralResponse
2226    {
2227        #[inline]
2228        unsafe fn encode(
2229            self,
2230            encoder: &mut fidl::encoding::Encoder<'_, D>,
2231            offset: usize,
2232            _depth: fidl::encoding::Depth,
2233        ) -> fidl::Result<()> {
2234            encoder.debug_check_bounds::<CentralDisconnectPeripheralResponse>(offset);
2235            // Delegate to tuple encoding.
2236            fidl::encoding::Encode::<CentralDisconnectPeripheralResponse, D>::encode(
2237                (
2238                    <fidl_fuchsia_bluetooth__common::Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
2239                ),
2240                encoder, offset, _depth
2241            )
2242        }
2243    }
2244    unsafe impl<
2245            D: fidl::encoding::ResourceDialect,
2246            T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::Status, D>,
2247        > fidl::encoding::Encode<CentralDisconnectPeripheralResponse, D> for (T0,)
2248    {
2249        #[inline]
2250        unsafe fn encode(
2251            self,
2252            encoder: &mut fidl::encoding::Encoder<'_, D>,
2253            offset: usize,
2254            depth: fidl::encoding::Depth,
2255        ) -> fidl::Result<()> {
2256            encoder.debug_check_bounds::<CentralDisconnectPeripheralResponse>(offset);
2257            // Zero out padding regions. There's no need to apply masks
2258            // because the unmasked parts will be overwritten by fields.
2259            // Write the fields.
2260            self.0.encode(encoder, offset + 0, depth)?;
2261            Ok(())
2262        }
2263    }
2264
2265    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2266        for CentralDisconnectPeripheralResponse
2267    {
2268        #[inline(always)]
2269        fn new_empty() -> Self {
2270            Self { status: fidl::new_empty!(fidl_fuchsia_bluetooth__common::Status, D) }
2271        }
2272
2273        #[inline]
2274        unsafe fn decode(
2275            &mut self,
2276            decoder: &mut fidl::encoding::Decoder<'_, D>,
2277            offset: usize,
2278            _depth: fidl::encoding::Depth,
2279        ) -> fidl::Result<()> {
2280            decoder.debug_check_bounds::<Self>(offset);
2281            // Verify that padding bytes are zero.
2282            fidl::decode!(
2283                fidl_fuchsia_bluetooth__common::Status,
2284                D,
2285                &mut self.status,
2286                decoder,
2287                offset + 0,
2288                _depth
2289            )?;
2290            Ok(())
2291        }
2292    }
2293
2294    impl fidl::encoding::ValueTypeMarker for CentralGetPeripheralRequest {
2295        type Borrowed<'a> = &'a Self;
2296        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2297            value
2298        }
2299    }
2300
2301    unsafe impl fidl::encoding::TypeMarker for CentralGetPeripheralRequest {
2302        type Owned = Self;
2303
2304        #[inline(always)]
2305        fn inline_align(_context: fidl::encoding::Context) -> usize {
2306            8
2307        }
2308
2309        #[inline(always)]
2310        fn inline_size(_context: fidl::encoding::Context) -> usize {
2311            16
2312        }
2313    }
2314
2315    unsafe impl<D: fidl::encoding::ResourceDialect>
2316        fidl::encoding::Encode<CentralGetPeripheralRequest, D> for &CentralGetPeripheralRequest
2317    {
2318        #[inline]
2319        unsafe fn encode(
2320            self,
2321            encoder: &mut fidl::encoding::Encoder<'_, D>,
2322            offset: usize,
2323            _depth: fidl::encoding::Depth,
2324        ) -> fidl::Result<()> {
2325            encoder.debug_check_bounds::<CentralGetPeripheralRequest>(offset);
2326            // Delegate to tuple encoding.
2327            fidl::encoding::Encode::<CentralGetPeripheralRequest, D>::encode(
2328                (<fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow(
2329                    &self.identifier,
2330                ),),
2331                encoder,
2332                offset,
2333                _depth,
2334            )
2335        }
2336    }
2337    unsafe impl<
2338            D: fidl::encoding::ResourceDialect,
2339            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<16>, D>,
2340        > fidl::encoding::Encode<CentralGetPeripheralRequest, D> for (T0,)
2341    {
2342        #[inline]
2343        unsafe fn encode(
2344            self,
2345            encoder: &mut fidl::encoding::Encoder<'_, D>,
2346            offset: usize,
2347            depth: fidl::encoding::Depth,
2348        ) -> fidl::Result<()> {
2349            encoder.debug_check_bounds::<CentralGetPeripheralRequest>(offset);
2350            // Zero out padding regions. There's no need to apply masks
2351            // because the unmasked parts will be overwritten by fields.
2352            // Write the fields.
2353            self.0.encode(encoder, offset + 0, depth)?;
2354            Ok(())
2355        }
2356    }
2357
2358    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2359        for CentralGetPeripheralRequest
2360    {
2361        #[inline(always)]
2362        fn new_empty() -> Self {
2363            Self { identifier: fidl::new_empty!(fidl::encoding::BoundedString<16>, D) }
2364        }
2365
2366        #[inline]
2367        unsafe fn decode(
2368            &mut self,
2369            decoder: &mut fidl::encoding::Decoder<'_, D>,
2370            offset: usize,
2371            _depth: fidl::encoding::Depth,
2372        ) -> fidl::Result<()> {
2373            decoder.debug_check_bounds::<Self>(offset);
2374            // Verify that padding bytes are zero.
2375            fidl::decode!(
2376                fidl::encoding::BoundedString<16>,
2377                D,
2378                &mut self.identifier,
2379                decoder,
2380                offset + 0,
2381                _depth
2382            )?;
2383            Ok(())
2384        }
2385    }
2386
2387    impl fidl::encoding::ValueTypeMarker for CentralGetPeripheralResponse {
2388        type Borrowed<'a> = &'a Self;
2389        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2390            value
2391        }
2392    }
2393
2394    unsafe impl fidl::encoding::TypeMarker for CentralGetPeripheralResponse {
2395        type Owned = Self;
2396
2397        #[inline(always)]
2398        fn inline_align(_context: fidl::encoding::Context) -> usize {
2399            8
2400        }
2401
2402        #[inline(always)]
2403        fn inline_size(_context: fidl::encoding::Context) -> usize {
2404            8
2405        }
2406    }
2407
2408    unsafe impl<D: fidl::encoding::ResourceDialect>
2409        fidl::encoding::Encode<CentralGetPeripheralResponse, D> for &CentralGetPeripheralResponse
2410    {
2411        #[inline]
2412        unsafe fn encode(
2413            self,
2414            encoder: &mut fidl::encoding::Encoder<'_, D>,
2415            offset: usize,
2416            _depth: fidl::encoding::Depth,
2417        ) -> fidl::Result<()> {
2418            encoder.debug_check_bounds::<CentralGetPeripheralResponse>(offset);
2419            // Delegate to tuple encoding.
2420            fidl::encoding::Encode::<CentralGetPeripheralResponse, D>::encode(
2421                (<fidl::encoding::Boxed<RemoteDevice> as fidl::encoding::ValueTypeMarker>::borrow(
2422                    &self.peripheral,
2423                ),),
2424                encoder,
2425                offset,
2426                _depth,
2427            )
2428        }
2429    }
2430    unsafe impl<
2431            D: fidl::encoding::ResourceDialect,
2432            T0: fidl::encoding::Encode<fidl::encoding::Boxed<RemoteDevice>, D>,
2433        > fidl::encoding::Encode<CentralGetPeripheralResponse, D> for (T0,)
2434    {
2435        #[inline]
2436        unsafe fn encode(
2437            self,
2438            encoder: &mut fidl::encoding::Encoder<'_, D>,
2439            offset: usize,
2440            depth: fidl::encoding::Depth,
2441        ) -> fidl::Result<()> {
2442            encoder.debug_check_bounds::<CentralGetPeripheralResponse>(offset);
2443            // Zero out padding regions. There's no need to apply masks
2444            // because the unmasked parts will be overwritten by fields.
2445            // Write the fields.
2446            self.0.encode(encoder, offset + 0, depth)?;
2447            Ok(())
2448        }
2449    }
2450
2451    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2452        for CentralGetPeripheralResponse
2453    {
2454        #[inline(always)]
2455        fn new_empty() -> Self {
2456            Self { peripheral: fidl::new_empty!(fidl::encoding::Boxed<RemoteDevice>, D) }
2457        }
2458
2459        #[inline]
2460        unsafe fn decode(
2461            &mut self,
2462            decoder: &mut fidl::encoding::Decoder<'_, D>,
2463            offset: usize,
2464            _depth: fidl::encoding::Depth,
2465        ) -> fidl::Result<()> {
2466            decoder.debug_check_bounds::<Self>(offset);
2467            // Verify that padding bytes are zero.
2468            fidl::decode!(
2469                fidl::encoding::Boxed<RemoteDevice>,
2470                D,
2471                &mut self.peripheral,
2472                decoder,
2473                offset + 0,
2474                _depth
2475            )?;
2476            Ok(())
2477        }
2478    }
2479
2480    impl fidl::encoding::ValueTypeMarker for CentralGetPeripheralsRequest {
2481        type Borrowed<'a> = &'a Self;
2482        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2483            value
2484        }
2485    }
2486
2487    unsafe impl fidl::encoding::TypeMarker for CentralGetPeripheralsRequest {
2488        type Owned = Self;
2489
2490        #[inline(always)]
2491        fn inline_align(_context: fidl::encoding::Context) -> usize {
2492            8
2493        }
2494
2495        #[inline(always)]
2496        fn inline_size(_context: fidl::encoding::Context) -> usize {
2497            16
2498        }
2499    }
2500
2501    unsafe impl<D: fidl::encoding::ResourceDialect>
2502        fidl::encoding::Encode<CentralGetPeripheralsRequest, D> for &CentralGetPeripheralsRequest
2503    {
2504        #[inline]
2505        unsafe fn encode(
2506            self,
2507            encoder: &mut fidl::encoding::Encoder<'_, D>,
2508            offset: usize,
2509            _depth: fidl::encoding::Depth,
2510        ) -> fidl::Result<()> {
2511            encoder.debug_check_bounds::<CentralGetPeripheralsRequest>(offset);
2512            // Delegate to tuple encoding.
2513            fidl::encoding::Encode::<CentralGetPeripheralsRequest, D>::encode(
2514                (<fidl::encoding::Optional<
2515                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
2516                > as fidl::encoding::ValueTypeMarker>::borrow(&self.service_uuids),),
2517                encoder,
2518                offset,
2519                _depth,
2520            )
2521        }
2522    }
2523    unsafe impl<
2524            D: fidl::encoding::ResourceDialect,
2525            T0: fidl::encoding::Encode<
2526                fidl::encoding::Optional<
2527                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
2528                >,
2529                D,
2530            >,
2531        > fidl::encoding::Encode<CentralGetPeripheralsRequest, D> for (T0,)
2532    {
2533        #[inline]
2534        unsafe fn encode(
2535            self,
2536            encoder: &mut fidl::encoding::Encoder<'_, D>,
2537            offset: usize,
2538            depth: fidl::encoding::Depth,
2539        ) -> fidl::Result<()> {
2540            encoder.debug_check_bounds::<CentralGetPeripheralsRequest>(offset);
2541            // Zero out padding regions. There's no need to apply masks
2542            // because the unmasked parts will be overwritten by fields.
2543            // Write the fields.
2544            self.0.encode(encoder, offset + 0, depth)?;
2545            Ok(())
2546        }
2547    }
2548
2549    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2550        for CentralGetPeripheralsRequest
2551    {
2552        #[inline(always)]
2553        fn new_empty() -> Self {
2554            Self {
2555                service_uuids: fidl::new_empty!(
2556                    fidl::encoding::Optional<
2557                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
2558                    >,
2559                    D
2560                ),
2561            }
2562        }
2563
2564        #[inline]
2565        unsafe fn decode(
2566            &mut self,
2567            decoder: &mut fidl::encoding::Decoder<'_, D>,
2568            offset: usize,
2569            _depth: fidl::encoding::Depth,
2570        ) -> fidl::Result<()> {
2571            decoder.debug_check_bounds::<Self>(offset);
2572            // Verify that padding bytes are zero.
2573            fidl::decode!(
2574                fidl::encoding::Optional<
2575                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
2576                >,
2577                D,
2578                &mut self.service_uuids,
2579                decoder,
2580                offset + 0,
2581                _depth
2582            )?;
2583            Ok(())
2584        }
2585    }
2586
2587    impl fidl::encoding::ValueTypeMarker for CentralGetPeripheralsResponse {
2588        type Borrowed<'a> = &'a Self;
2589        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2590            value
2591        }
2592    }
2593
2594    unsafe impl fidl::encoding::TypeMarker for CentralGetPeripheralsResponse {
2595        type Owned = Self;
2596
2597        #[inline(always)]
2598        fn inline_align(_context: fidl::encoding::Context) -> usize {
2599            8
2600        }
2601
2602        #[inline(always)]
2603        fn inline_size(_context: fidl::encoding::Context) -> usize {
2604            16
2605        }
2606    }
2607
2608    unsafe impl<D: fidl::encoding::ResourceDialect>
2609        fidl::encoding::Encode<CentralGetPeripheralsResponse, D>
2610        for &CentralGetPeripheralsResponse
2611    {
2612        #[inline]
2613        unsafe fn encode(
2614            self,
2615            encoder: &mut fidl::encoding::Encoder<'_, D>,
2616            offset: usize,
2617            _depth: fidl::encoding::Depth,
2618        ) -> fidl::Result<()> {
2619            encoder.debug_check_bounds::<CentralGetPeripheralsResponse>(offset);
2620            // Delegate to tuple encoding.
2621            fidl::encoding::Encode::<CentralGetPeripheralsResponse, D>::encode(
2622                (
2623                    <fidl::encoding::UnboundedVector<RemoteDevice> as fidl::encoding::ValueTypeMarker>::borrow(&self.peripherals),
2624                ),
2625                encoder, offset, _depth
2626            )
2627        }
2628    }
2629    unsafe impl<
2630            D: fidl::encoding::ResourceDialect,
2631            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<RemoteDevice>, D>,
2632        > fidl::encoding::Encode<CentralGetPeripheralsResponse, D> for (T0,)
2633    {
2634        #[inline]
2635        unsafe fn encode(
2636            self,
2637            encoder: &mut fidl::encoding::Encoder<'_, D>,
2638            offset: usize,
2639            depth: fidl::encoding::Depth,
2640        ) -> fidl::Result<()> {
2641            encoder.debug_check_bounds::<CentralGetPeripheralsResponse>(offset);
2642            // Zero out padding regions. There's no need to apply masks
2643            // because the unmasked parts will be overwritten by fields.
2644            // Write the fields.
2645            self.0.encode(encoder, offset + 0, depth)?;
2646            Ok(())
2647        }
2648    }
2649
2650    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2651        for CentralGetPeripheralsResponse
2652    {
2653        #[inline(always)]
2654        fn new_empty() -> Self {
2655            Self { peripherals: fidl::new_empty!(fidl::encoding::UnboundedVector<RemoteDevice>, D) }
2656        }
2657
2658        #[inline]
2659        unsafe fn decode(
2660            &mut self,
2661            decoder: &mut fidl::encoding::Decoder<'_, D>,
2662            offset: usize,
2663            _depth: fidl::encoding::Depth,
2664        ) -> fidl::Result<()> {
2665            decoder.debug_check_bounds::<Self>(offset);
2666            // Verify that padding bytes are zero.
2667            fidl::decode!(
2668                fidl::encoding::UnboundedVector<RemoteDevice>,
2669                D,
2670                &mut self.peripherals,
2671                decoder,
2672                offset + 0,
2673                _depth
2674            )?;
2675            Ok(())
2676        }
2677    }
2678
2679    impl fidl::encoding::ValueTypeMarker for CentralOnDeviceDiscoveredRequest {
2680        type Borrowed<'a> = &'a Self;
2681        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2682            value
2683        }
2684    }
2685
2686    unsafe impl fidl::encoding::TypeMarker for CentralOnDeviceDiscoveredRequest {
2687        type Owned = Self;
2688
2689        #[inline(always)]
2690        fn inline_align(_context: fidl::encoding::Context) -> usize {
2691            8
2692        }
2693
2694        #[inline(always)]
2695        fn inline_size(_context: fidl::encoding::Context) -> usize {
2696            40
2697        }
2698    }
2699
2700    unsafe impl<D: fidl::encoding::ResourceDialect>
2701        fidl::encoding::Encode<CentralOnDeviceDiscoveredRequest, D>
2702        for &CentralOnDeviceDiscoveredRequest
2703    {
2704        #[inline]
2705        unsafe fn encode(
2706            self,
2707            encoder: &mut fidl::encoding::Encoder<'_, D>,
2708            offset: usize,
2709            _depth: fidl::encoding::Depth,
2710        ) -> fidl::Result<()> {
2711            encoder.debug_check_bounds::<CentralOnDeviceDiscoveredRequest>(offset);
2712            // Delegate to tuple encoding.
2713            fidl::encoding::Encode::<CentralOnDeviceDiscoveredRequest, D>::encode(
2714                (<RemoteDevice as fidl::encoding::ValueTypeMarker>::borrow(&self.device),),
2715                encoder,
2716                offset,
2717                _depth,
2718            )
2719        }
2720    }
2721    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<RemoteDevice, D>>
2722        fidl::encoding::Encode<CentralOnDeviceDiscoveredRequest, D> for (T0,)
2723    {
2724        #[inline]
2725        unsafe fn encode(
2726            self,
2727            encoder: &mut fidl::encoding::Encoder<'_, D>,
2728            offset: usize,
2729            depth: fidl::encoding::Depth,
2730        ) -> fidl::Result<()> {
2731            encoder.debug_check_bounds::<CentralOnDeviceDiscoveredRequest>(offset);
2732            // Zero out padding regions. There's no need to apply masks
2733            // because the unmasked parts will be overwritten by fields.
2734            // Write the fields.
2735            self.0.encode(encoder, offset + 0, depth)?;
2736            Ok(())
2737        }
2738    }
2739
2740    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2741        for CentralOnDeviceDiscoveredRequest
2742    {
2743        #[inline(always)]
2744        fn new_empty() -> Self {
2745            Self { device: fidl::new_empty!(RemoteDevice, D) }
2746        }
2747
2748        #[inline]
2749        unsafe fn decode(
2750            &mut self,
2751            decoder: &mut fidl::encoding::Decoder<'_, D>,
2752            offset: usize,
2753            _depth: fidl::encoding::Depth,
2754        ) -> fidl::Result<()> {
2755            decoder.debug_check_bounds::<Self>(offset);
2756            // Verify that padding bytes are zero.
2757            fidl::decode!(RemoteDevice, D, &mut self.device, decoder, offset + 0, _depth)?;
2758            Ok(())
2759        }
2760    }
2761
2762    impl fidl::encoding::ValueTypeMarker for CentralOnPeripheralDisconnectedRequest {
2763        type Borrowed<'a> = &'a Self;
2764        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2765            value
2766        }
2767    }
2768
2769    unsafe impl fidl::encoding::TypeMarker for CentralOnPeripheralDisconnectedRequest {
2770        type Owned = Self;
2771
2772        #[inline(always)]
2773        fn inline_align(_context: fidl::encoding::Context) -> usize {
2774            8
2775        }
2776
2777        #[inline(always)]
2778        fn inline_size(_context: fidl::encoding::Context) -> usize {
2779            16
2780        }
2781    }
2782
2783    unsafe impl<D: fidl::encoding::ResourceDialect>
2784        fidl::encoding::Encode<CentralOnPeripheralDisconnectedRequest, D>
2785        for &CentralOnPeripheralDisconnectedRequest
2786    {
2787        #[inline]
2788        unsafe fn encode(
2789            self,
2790            encoder: &mut fidl::encoding::Encoder<'_, D>,
2791            offset: usize,
2792            _depth: fidl::encoding::Depth,
2793        ) -> fidl::Result<()> {
2794            encoder.debug_check_bounds::<CentralOnPeripheralDisconnectedRequest>(offset);
2795            // Delegate to tuple encoding.
2796            fidl::encoding::Encode::<CentralOnPeripheralDisconnectedRequest, D>::encode(
2797                (<fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow(
2798                    &self.identifier,
2799                ),),
2800                encoder,
2801                offset,
2802                _depth,
2803            )
2804        }
2805    }
2806    unsafe impl<
2807            D: fidl::encoding::ResourceDialect,
2808            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<16>, D>,
2809        > fidl::encoding::Encode<CentralOnPeripheralDisconnectedRequest, D> for (T0,)
2810    {
2811        #[inline]
2812        unsafe fn encode(
2813            self,
2814            encoder: &mut fidl::encoding::Encoder<'_, D>,
2815            offset: usize,
2816            depth: fidl::encoding::Depth,
2817        ) -> fidl::Result<()> {
2818            encoder.debug_check_bounds::<CentralOnPeripheralDisconnectedRequest>(offset);
2819            // Zero out padding regions. There's no need to apply masks
2820            // because the unmasked parts will be overwritten by fields.
2821            // Write the fields.
2822            self.0.encode(encoder, offset + 0, depth)?;
2823            Ok(())
2824        }
2825    }
2826
2827    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2828        for CentralOnPeripheralDisconnectedRequest
2829    {
2830        #[inline(always)]
2831        fn new_empty() -> Self {
2832            Self { identifier: fidl::new_empty!(fidl::encoding::BoundedString<16>, D) }
2833        }
2834
2835        #[inline]
2836        unsafe fn decode(
2837            &mut self,
2838            decoder: &mut fidl::encoding::Decoder<'_, D>,
2839            offset: usize,
2840            _depth: fidl::encoding::Depth,
2841        ) -> fidl::Result<()> {
2842            decoder.debug_check_bounds::<Self>(offset);
2843            // Verify that padding bytes are zero.
2844            fidl::decode!(
2845                fidl::encoding::BoundedString<16>,
2846                D,
2847                &mut self.identifier,
2848                decoder,
2849                offset + 0,
2850                _depth
2851            )?;
2852            Ok(())
2853        }
2854    }
2855
2856    impl fidl::encoding::ValueTypeMarker for CentralOnScanStateChangedRequest {
2857        type Borrowed<'a> = &'a Self;
2858        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2859            value
2860        }
2861    }
2862
2863    unsafe impl fidl::encoding::TypeMarker for CentralOnScanStateChangedRequest {
2864        type Owned = Self;
2865
2866        #[inline(always)]
2867        fn inline_align(_context: fidl::encoding::Context) -> usize {
2868            1
2869        }
2870
2871        #[inline(always)]
2872        fn inline_size(_context: fidl::encoding::Context) -> usize {
2873            1
2874        }
2875    }
2876
2877    unsafe impl<D: fidl::encoding::ResourceDialect>
2878        fidl::encoding::Encode<CentralOnScanStateChangedRequest, D>
2879        for &CentralOnScanStateChangedRequest
2880    {
2881        #[inline]
2882        unsafe fn encode(
2883            self,
2884            encoder: &mut fidl::encoding::Encoder<'_, D>,
2885            offset: usize,
2886            _depth: fidl::encoding::Depth,
2887        ) -> fidl::Result<()> {
2888            encoder.debug_check_bounds::<CentralOnScanStateChangedRequest>(offset);
2889            // Delegate to tuple encoding.
2890            fidl::encoding::Encode::<CentralOnScanStateChangedRequest, D>::encode(
2891                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.scanning),),
2892                encoder,
2893                offset,
2894                _depth,
2895            )
2896        }
2897    }
2898    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
2899        fidl::encoding::Encode<CentralOnScanStateChangedRequest, D> for (T0,)
2900    {
2901        #[inline]
2902        unsafe fn encode(
2903            self,
2904            encoder: &mut fidl::encoding::Encoder<'_, D>,
2905            offset: usize,
2906            depth: fidl::encoding::Depth,
2907        ) -> fidl::Result<()> {
2908            encoder.debug_check_bounds::<CentralOnScanStateChangedRequest>(offset);
2909            // Zero out padding regions. There's no need to apply masks
2910            // because the unmasked parts will be overwritten by fields.
2911            // Write the fields.
2912            self.0.encode(encoder, offset + 0, depth)?;
2913            Ok(())
2914        }
2915    }
2916
2917    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2918        for CentralOnScanStateChangedRequest
2919    {
2920        #[inline(always)]
2921        fn new_empty() -> Self {
2922            Self { scanning: fidl::new_empty!(bool, D) }
2923        }
2924
2925        #[inline]
2926        unsafe fn decode(
2927            &mut self,
2928            decoder: &mut fidl::encoding::Decoder<'_, D>,
2929            offset: usize,
2930            _depth: fidl::encoding::Depth,
2931        ) -> fidl::Result<()> {
2932            decoder.debug_check_bounds::<Self>(offset);
2933            // Verify that padding bytes are zero.
2934            fidl::decode!(bool, D, &mut self.scanning, decoder, offset + 0, _depth)?;
2935            Ok(())
2936        }
2937    }
2938
2939    impl fidl::encoding::ValueTypeMarker for CentralStartScanRequest {
2940        type Borrowed<'a> = &'a Self;
2941        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2942            value
2943        }
2944    }
2945
2946    unsafe impl fidl::encoding::TypeMarker for CentralStartScanRequest {
2947        type Owned = Self;
2948
2949        #[inline(always)]
2950        fn inline_align(_context: fidl::encoding::Context) -> usize {
2951            8
2952        }
2953
2954        #[inline(always)]
2955        fn inline_size(_context: fidl::encoding::Context) -> usize {
2956            8
2957        }
2958    }
2959
2960    unsafe impl<D: fidl::encoding::ResourceDialect>
2961        fidl::encoding::Encode<CentralStartScanRequest, D> for &CentralStartScanRequest
2962    {
2963        #[inline]
2964        unsafe fn encode(
2965            self,
2966            encoder: &mut fidl::encoding::Encoder<'_, D>,
2967            offset: usize,
2968            _depth: fidl::encoding::Depth,
2969        ) -> fidl::Result<()> {
2970            encoder.debug_check_bounds::<CentralStartScanRequest>(offset);
2971            // Delegate to tuple encoding.
2972            fidl::encoding::Encode::<CentralStartScanRequest, D>::encode(
2973                (<fidl::encoding::Boxed<ScanFilter> as fidl::encoding::ValueTypeMarker>::borrow(
2974                    &self.filter,
2975                ),),
2976                encoder,
2977                offset,
2978                _depth,
2979            )
2980        }
2981    }
2982    unsafe impl<
2983            D: fidl::encoding::ResourceDialect,
2984            T0: fidl::encoding::Encode<fidl::encoding::Boxed<ScanFilter>, D>,
2985        > fidl::encoding::Encode<CentralStartScanRequest, D> for (T0,)
2986    {
2987        #[inline]
2988        unsafe fn encode(
2989            self,
2990            encoder: &mut fidl::encoding::Encoder<'_, D>,
2991            offset: usize,
2992            depth: fidl::encoding::Depth,
2993        ) -> fidl::Result<()> {
2994            encoder.debug_check_bounds::<CentralStartScanRequest>(offset);
2995            // Zero out padding regions. There's no need to apply masks
2996            // because the unmasked parts will be overwritten by fields.
2997            // Write the fields.
2998            self.0.encode(encoder, offset + 0, depth)?;
2999            Ok(())
3000        }
3001    }
3002
3003    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3004        for CentralStartScanRequest
3005    {
3006        #[inline(always)]
3007        fn new_empty() -> Self {
3008            Self { filter: fidl::new_empty!(fidl::encoding::Boxed<ScanFilter>, D) }
3009        }
3010
3011        #[inline]
3012        unsafe fn decode(
3013            &mut self,
3014            decoder: &mut fidl::encoding::Decoder<'_, D>,
3015            offset: usize,
3016            _depth: fidl::encoding::Depth,
3017        ) -> fidl::Result<()> {
3018            decoder.debug_check_bounds::<Self>(offset);
3019            // Verify that padding bytes are zero.
3020            fidl::decode!(
3021                fidl::encoding::Boxed<ScanFilter>,
3022                D,
3023                &mut self.filter,
3024                decoder,
3025                offset + 0,
3026                _depth
3027            )?;
3028            Ok(())
3029        }
3030    }
3031
3032    impl fidl::encoding::ValueTypeMarker for CentralStartScanResponse {
3033        type Borrowed<'a> = &'a Self;
3034        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3035            value
3036        }
3037    }
3038
3039    unsafe impl fidl::encoding::TypeMarker for CentralStartScanResponse {
3040        type Owned = Self;
3041
3042        #[inline(always)]
3043        fn inline_align(_context: fidl::encoding::Context) -> usize {
3044            8
3045        }
3046
3047        #[inline(always)]
3048        fn inline_size(_context: fidl::encoding::Context) -> usize {
3049            8
3050        }
3051    }
3052
3053    unsafe impl<D: fidl::encoding::ResourceDialect>
3054        fidl::encoding::Encode<CentralStartScanResponse, D> for &CentralStartScanResponse
3055    {
3056        #[inline]
3057        unsafe fn encode(
3058            self,
3059            encoder: &mut fidl::encoding::Encoder<'_, D>,
3060            offset: usize,
3061            _depth: fidl::encoding::Depth,
3062        ) -> fidl::Result<()> {
3063            encoder.debug_check_bounds::<CentralStartScanResponse>(offset);
3064            // Delegate to tuple encoding.
3065            fidl::encoding::Encode::<CentralStartScanResponse, D>::encode(
3066                (
3067                    <fidl_fuchsia_bluetooth__common::Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
3068                ),
3069                encoder, offset, _depth
3070            )
3071        }
3072    }
3073    unsafe impl<
3074            D: fidl::encoding::ResourceDialect,
3075            T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::Status, D>,
3076        > fidl::encoding::Encode<CentralStartScanResponse, D> for (T0,)
3077    {
3078        #[inline]
3079        unsafe fn encode(
3080            self,
3081            encoder: &mut fidl::encoding::Encoder<'_, D>,
3082            offset: usize,
3083            depth: fidl::encoding::Depth,
3084        ) -> fidl::Result<()> {
3085            encoder.debug_check_bounds::<CentralStartScanResponse>(offset);
3086            // Zero out padding regions. There's no need to apply masks
3087            // because the unmasked parts will be overwritten by fields.
3088            // Write the fields.
3089            self.0.encode(encoder, offset + 0, depth)?;
3090            Ok(())
3091        }
3092    }
3093
3094    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3095        for CentralStartScanResponse
3096    {
3097        #[inline(always)]
3098        fn new_empty() -> Self {
3099            Self { status: fidl::new_empty!(fidl_fuchsia_bluetooth__common::Status, D) }
3100        }
3101
3102        #[inline]
3103        unsafe fn decode(
3104            &mut self,
3105            decoder: &mut fidl::encoding::Decoder<'_, D>,
3106            offset: usize,
3107            _depth: fidl::encoding::Depth,
3108        ) -> fidl::Result<()> {
3109            decoder.debug_check_bounds::<Self>(offset);
3110            // Verify that padding bytes are zero.
3111            fidl::decode!(
3112                fidl_fuchsia_bluetooth__common::Status,
3113                D,
3114                &mut self.status,
3115                decoder,
3116                offset + 0,
3117                _depth
3118            )?;
3119            Ok(())
3120        }
3121    }
3122
3123    impl fidl::encoding::ValueTypeMarker for ManufacturerData {
3124        type Borrowed<'a> = &'a Self;
3125        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3126            value
3127        }
3128    }
3129
3130    unsafe impl fidl::encoding::TypeMarker for ManufacturerData {
3131        type Owned = Self;
3132
3133        #[inline(always)]
3134        fn inline_align(_context: fidl::encoding::Context) -> usize {
3135            8
3136        }
3137
3138        #[inline(always)]
3139        fn inline_size(_context: fidl::encoding::Context) -> usize {
3140            24
3141        }
3142    }
3143
3144    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ManufacturerData, D>
3145        for &ManufacturerData
3146    {
3147        #[inline]
3148        unsafe fn encode(
3149            self,
3150            encoder: &mut fidl::encoding::Encoder<'_, D>,
3151            offset: usize,
3152            _depth: fidl::encoding::Depth,
3153        ) -> fidl::Result<()> {
3154            encoder.debug_check_bounds::<ManufacturerData>(offset);
3155            // Delegate to tuple encoding.
3156            fidl::encoding::Encode::<ManufacturerData, D>::encode(
3157                (
3158                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.company_id),
3159                    <fidl::encoding::Vector<u8, 252> as fidl::encoding::ValueTypeMarker>::borrow(
3160                        &self.data,
3161                    ),
3162                ),
3163                encoder,
3164                offset,
3165                _depth,
3166            )
3167        }
3168    }
3169    unsafe impl<
3170            D: fidl::encoding::ResourceDialect,
3171            T0: fidl::encoding::Encode<u16, D>,
3172            T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 252>, D>,
3173        > fidl::encoding::Encode<ManufacturerData, D> for (T0, T1)
3174    {
3175        #[inline]
3176        unsafe fn encode(
3177            self,
3178            encoder: &mut fidl::encoding::Encoder<'_, D>,
3179            offset: usize,
3180            depth: fidl::encoding::Depth,
3181        ) -> fidl::Result<()> {
3182            encoder.debug_check_bounds::<ManufacturerData>(offset);
3183            // Zero out padding regions. There's no need to apply masks
3184            // because the unmasked parts will be overwritten by fields.
3185            unsafe {
3186                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
3187                (ptr as *mut u64).write_unaligned(0);
3188            }
3189            // Write the fields.
3190            self.0.encode(encoder, offset + 0, depth)?;
3191            self.1.encode(encoder, offset + 8, depth)?;
3192            Ok(())
3193        }
3194    }
3195
3196    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ManufacturerData {
3197        #[inline(always)]
3198        fn new_empty() -> Self {
3199            Self {
3200                company_id: fidl::new_empty!(u16, D),
3201                data: fidl::new_empty!(fidl::encoding::Vector<u8, 252>, D),
3202            }
3203        }
3204
3205        #[inline]
3206        unsafe fn decode(
3207            &mut self,
3208            decoder: &mut fidl::encoding::Decoder<'_, D>,
3209            offset: usize,
3210            _depth: fidl::encoding::Depth,
3211        ) -> fidl::Result<()> {
3212            decoder.debug_check_bounds::<Self>(offset);
3213            // Verify that padding bytes are zero.
3214            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
3215            let padval = unsafe { (ptr as *const u64).read_unaligned() };
3216            let mask = 0xffffffffffff0000u64;
3217            let maskedval = padval & mask;
3218            if maskedval != 0 {
3219                return Err(fidl::Error::NonZeroPadding {
3220                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
3221                });
3222            }
3223            fidl::decode!(u16, D, &mut self.company_id, decoder, offset + 0, _depth)?;
3224            fidl::decode!(fidl::encoding::Vector<u8, 252>, D, &mut self.data, decoder, offset + 8, _depth)?;
3225            Ok(())
3226        }
3227    }
3228
3229    impl fidl::encoding::ValueTypeMarker for ManufacturerSpecificDataEntry {
3230        type Borrowed<'a> = &'a Self;
3231        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3232            value
3233        }
3234    }
3235
3236    unsafe impl fidl::encoding::TypeMarker for ManufacturerSpecificDataEntry {
3237        type Owned = Self;
3238
3239        #[inline(always)]
3240        fn inline_align(_context: fidl::encoding::Context) -> usize {
3241            8
3242        }
3243
3244        #[inline(always)]
3245        fn inline_size(_context: fidl::encoding::Context) -> usize {
3246            24
3247        }
3248    }
3249
3250    unsafe impl<D: fidl::encoding::ResourceDialect>
3251        fidl::encoding::Encode<ManufacturerSpecificDataEntry, D>
3252        for &ManufacturerSpecificDataEntry
3253    {
3254        #[inline]
3255        unsafe fn encode(
3256            self,
3257            encoder: &mut fidl::encoding::Encoder<'_, D>,
3258            offset: usize,
3259            _depth: fidl::encoding::Depth,
3260        ) -> fidl::Result<()> {
3261            encoder.debug_check_bounds::<ManufacturerSpecificDataEntry>(offset);
3262            // Delegate to tuple encoding.
3263            fidl::encoding::Encode::<ManufacturerSpecificDataEntry, D>::encode(
3264                (
3265                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.company_id),
3266                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
3267                ),
3268                encoder, offset, _depth
3269            )
3270        }
3271    }
3272    unsafe impl<
3273            D: fidl::encoding::ResourceDialect,
3274            T0: fidl::encoding::Encode<u16, D>,
3275            T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
3276        > fidl::encoding::Encode<ManufacturerSpecificDataEntry, D> for (T0, T1)
3277    {
3278        #[inline]
3279        unsafe fn encode(
3280            self,
3281            encoder: &mut fidl::encoding::Encoder<'_, D>,
3282            offset: usize,
3283            depth: fidl::encoding::Depth,
3284        ) -> fidl::Result<()> {
3285            encoder.debug_check_bounds::<ManufacturerSpecificDataEntry>(offset);
3286            // Zero out padding regions. There's no need to apply masks
3287            // because the unmasked parts will be overwritten by fields.
3288            unsafe {
3289                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
3290                (ptr as *mut u64).write_unaligned(0);
3291            }
3292            // Write the fields.
3293            self.0.encode(encoder, offset + 0, depth)?;
3294            self.1.encode(encoder, offset + 8, depth)?;
3295            Ok(())
3296        }
3297    }
3298
3299    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3300        for ManufacturerSpecificDataEntry
3301    {
3302        #[inline(always)]
3303        fn new_empty() -> Self {
3304            Self {
3305                company_id: fidl::new_empty!(u16, D),
3306                data: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
3307            }
3308        }
3309
3310        #[inline]
3311        unsafe fn decode(
3312            &mut self,
3313            decoder: &mut fidl::encoding::Decoder<'_, D>,
3314            offset: usize,
3315            _depth: fidl::encoding::Depth,
3316        ) -> fidl::Result<()> {
3317            decoder.debug_check_bounds::<Self>(offset);
3318            // Verify that padding bytes are zero.
3319            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
3320            let padval = unsafe { (ptr as *const u64).read_unaligned() };
3321            let mask = 0xffffffffffff0000u64;
3322            let maskedval = padval & mask;
3323            if maskedval != 0 {
3324                return Err(fidl::Error::NonZeroPadding {
3325                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
3326                });
3327            }
3328            fidl::decode!(u16, D, &mut self.company_id, decoder, offset + 0, _depth)?;
3329            fidl::decode!(
3330                fidl::encoding::UnboundedVector<u8>,
3331                D,
3332                &mut self.data,
3333                decoder,
3334                offset + 8,
3335                _depth
3336            )?;
3337            Ok(())
3338        }
3339    }
3340
3341    impl fidl::encoding::ValueTypeMarker for RemoteDevice {
3342        type Borrowed<'a> = &'a Self;
3343        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3344            value
3345        }
3346    }
3347
3348    unsafe impl fidl::encoding::TypeMarker for RemoteDevice {
3349        type Owned = Self;
3350
3351        #[inline(always)]
3352        fn inline_align(_context: fidl::encoding::Context) -> usize {
3353            8
3354        }
3355
3356        #[inline(always)]
3357        fn inline_size(_context: fidl::encoding::Context) -> usize {
3358            40
3359        }
3360    }
3361
3362    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RemoteDevice, D>
3363        for &RemoteDevice
3364    {
3365        #[inline]
3366        unsafe fn encode(
3367            self,
3368            encoder: &mut fidl::encoding::Encoder<'_, D>,
3369            offset: usize,
3370            _depth: fidl::encoding::Depth,
3371        ) -> fidl::Result<()> {
3372            encoder.debug_check_bounds::<RemoteDevice>(offset);
3373            // Delegate to tuple encoding.
3374            fidl::encoding::Encode::<RemoteDevice, D>::encode(
3375                (
3376                    <fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow(&self.identifier),
3377                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.connectable),
3378                    <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8> as fidl::encoding::ValueTypeMarker>::borrow(&self.rssi),
3379                    <fidl::encoding::Boxed<AdvertisingDataDeprecated> as fidl::encoding::ValueTypeMarker>::borrow(&self.advertising_data),
3380                ),
3381                encoder, offset, _depth
3382            )
3383        }
3384    }
3385    unsafe impl<
3386            D: fidl::encoding::ResourceDialect,
3387            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<16>, D>,
3388            T1: fidl::encoding::Encode<bool, D>,
3389            T2: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>, D>,
3390            T3: fidl::encoding::Encode<fidl::encoding::Boxed<AdvertisingDataDeprecated>, D>,
3391        > fidl::encoding::Encode<RemoteDevice, D> for (T0, T1, T2, T3)
3392    {
3393        #[inline]
3394        unsafe fn encode(
3395            self,
3396            encoder: &mut fidl::encoding::Encoder<'_, D>,
3397            offset: usize,
3398            depth: fidl::encoding::Depth,
3399        ) -> fidl::Result<()> {
3400            encoder.debug_check_bounds::<RemoteDevice>(offset);
3401            // Zero out padding regions. There's no need to apply masks
3402            // because the unmasked parts will be overwritten by fields.
3403            unsafe {
3404                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
3405                (ptr as *mut u64).write_unaligned(0);
3406            }
3407            // Write the fields.
3408            self.0.encode(encoder, offset + 0, depth)?;
3409            self.1.encode(encoder, offset + 16, depth)?;
3410            self.2.encode(encoder, offset + 24, depth)?;
3411            self.3.encode(encoder, offset + 32, depth)?;
3412            Ok(())
3413        }
3414    }
3415
3416    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RemoteDevice {
3417        #[inline(always)]
3418        fn new_empty() -> Self {
3419            Self {
3420                identifier: fidl::new_empty!(fidl::encoding::BoundedString<16>, D),
3421                connectable: fidl::new_empty!(bool, D),
3422                rssi: fidl::new_empty!(
3423                    fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
3424                    D
3425                ),
3426                advertising_data: fidl::new_empty!(
3427                    fidl::encoding::Boxed<AdvertisingDataDeprecated>,
3428                    D
3429                ),
3430            }
3431        }
3432
3433        #[inline]
3434        unsafe fn decode(
3435            &mut self,
3436            decoder: &mut fidl::encoding::Decoder<'_, D>,
3437            offset: usize,
3438            _depth: fidl::encoding::Depth,
3439        ) -> fidl::Result<()> {
3440            decoder.debug_check_bounds::<Self>(offset);
3441            // Verify that padding bytes are zero.
3442            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
3443            let padval = unsafe { (ptr as *const u64).read_unaligned() };
3444            let mask = 0xffffffffffffff00u64;
3445            let maskedval = padval & mask;
3446            if maskedval != 0 {
3447                return Err(fidl::Error::NonZeroPadding {
3448                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
3449                });
3450            }
3451            fidl::decode!(
3452                fidl::encoding::BoundedString<16>,
3453                D,
3454                &mut self.identifier,
3455                decoder,
3456                offset + 0,
3457                _depth
3458            )?;
3459            fidl::decode!(bool, D, &mut self.connectable, decoder, offset + 16, _depth)?;
3460            fidl::decode!(
3461                fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
3462                D,
3463                &mut self.rssi,
3464                decoder,
3465                offset + 24,
3466                _depth
3467            )?;
3468            fidl::decode!(
3469                fidl::encoding::Boxed<AdvertisingDataDeprecated>,
3470                D,
3471                &mut self.advertising_data,
3472                decoder,
3473                offset + 32,
3474                _depth
3475            )?;
3476            Ok(())
3477        }
3478    }
3479
3480    impl fidl::encoding::ValueTypeMarker for ScanFilter {
3481        type Borrowed<'a> = &'a Self;
3482        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3483            value
3484        }
3485    }
3486
3487    unsafe impl fidl::encoding::TypeMarker for ScanFilter {
3488        type Owned = Self;
3489
3490        #[inline(always)]
3491        fn inline_align(_context: fidl::encoding::Context) -> usize {
3492            8
3493        }
3494
3495        #[inline(always)]
3496        fn inline_size(_context: fidl::encoding::Context) -> usize {
3497            72
3498        }
3499    }
3500
3501    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ScanFilter, D>
3502        for &ScanFilter
3503    {
3504        #[inline]
3505        unsafe fn encode(
3506            self,
3507            encoder: &mut fidl::encoding::Encoder<'_, D>,
3508            offset: usize,
3509            _depth: fidl::encoding::Depth,
3510        ) -> fidl::Result<()> {
3511            encoder.debug_check_bounds::<ScanFilter>(offset);
3512            // Delegate to tuple encoding.
3513            fidl::encoding::Encode::<ScanFilter, D>::encode(
3514                (
3515                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.service_uuids),
3516                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.service_data_uuids),
3517                    <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16> as fidl::encoding::ValueTypeMarker>::borrow(&self.manufacturer_identifier),
3518                    <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Bool> as fidl::encoding::ValueTypeMarker>::borrow(&self.connectable),
3519                    <fidl::encoding::Optional<fidl::encoding::BoundedString<248>> as fidl::encoding::ValueTypeMarker>::borrow(&self.name_substring),
3520                    <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8> as fidl::encoding::ValueTypeMarker>::borrow(&self.max_path_loss),
3521                ),
3522                encoder, offset, _depth
3523            )
3524        }
3525    }
3526    unsafe impl<
3527            D: fidl::encoding::ResourceDialect,
3528            T0: fidl::encoding::Encode<
3529                fidl::encoding::Optional<
3530                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3531                >,
3532                D,
3533            >,
3534            T1: fidl::encoding::Encode<
3535                fidl::encoding::Optional<
3536                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3537                >,
3538                D,
3539            >,
3540            T2: fidl::encoding::Encode<
3541                fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
3542                D,
3543            >,
3544            T3: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Bool>, D>,
3545            T4: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<248>>, D>,
3546            T5: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>, D>,
3547        > fidl::encoding::Encode<ScanFilter, D> for (T0, T1, T2, T3, T4, T5)
3548    {
3549        #[inline]
3550        unsafe fn encode(
3551            self,
3552            encoder: &mut fidl::encoding::Encoder<'_, D>,
3553            offset: usize,
3554            depth: fidl::encoding::Depth,
3555        ) -> fidl::Result<()> {
3556            encoder.debug_check_bounds::<ScanFilter>(offset);
3557            // Zero out padding regions. There's no need to apply masks
3558            // because the unmasked parts will be overwritten by fields.
3559            // Write the fields.
3560            self.0.encode(encoder, offset + 0, depth)?;
3561            self.1.encode(encoder, offset + 16, depth)?;
3562            self.2.encode(encoder, offset + 32, depth)?;
3563            self.3.encode(encoder, offset + 40, depth)?;
3564            self.4.encode(encoder, offset + 48, depth)?;
3565            self.5.encode(encoder, offset + 64, depth)?;
3566            Ok(())
3567        }
3568    }
3569
3570    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanFilter {
3571        #[inline(always)]
3572        fn new_empty() -> Self {
3573            Self {
3574                service_uuids: fidl::new_empty!(
3575                    fidl::encoding::Optional<
3576                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3577                    >,
3578                    D
3579                ),
3580                service_data_uuids: fidl::new_empty!(
3581                    fidl::encoding::Optional<
3582                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3583                    >,
3584                    D
3585                ),
3586                manufacturer_identifier: fidl::new_empty!(
3587                    fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
3588                    D
3589                ),
3590                connectable: fidl::new_empty!(
3591                    fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Bool>,
3592                    D
3593                ),
3594                name_substring: fidl::new_empty!(
3595                    fidl::encoding::Optional<fidl::encoding::BoundedString<248>>,
3596                    D
3597                ),
3598                max_path_loss: fidl::new_empty!(
3599                    fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
3600                    D
3601                ),
3602            }
3603        }
3604
3605        #[inline]
3606        unsafe fn decode(
3607            &mut self,
3608            decoder: &mut fidl::encoding::Decoder<'_, D>,
3609            offset: usize,
3610            _depth: fidl::encoding::Depth,
3611        ) -> fidl::Result<()> {
3612            decoder.debug_check_bounds::<Self>(offset);
3613            // Verify that padding bytes are zero.
3614            fidl::decode!(
3615                fidl::encoding::Optional<
3616                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3617                >,
3618                D,
3619                &mut self.service_uuids,
3620                decoder,
3621                offset + 0,
3622                _depth
3623            )?;
3624            fidl::decode!(
3625                fidl::encoding::Optional<
3626                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3627                >,
3628                D,
3629                &mut self.service_data_uuids,
3630                decoder,
3631                offset + 16,
3632                _depth
3633            )?;
3634            fidl::decode!(
3635                fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
3636                D,
3637                &mut self.manufacturer_identifier,
3638                decoder,
3639                offset + 32,
3640                _depth
3641            )?;
3642            fidl::decode!(
3643                fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Bool>,
3644                D,
3645                &mut self.connectable,
3646                decoder,
3647                offset + 40,
3648                _depth
3649            )?;
3650            fidl::decode!(
3651                fidl::encoding::Optional<fidl::encoding::BoundedString<248>>,
3652                D,
3653                &mut self.name_substring,
3654                decoder,
3655                offset + 48,
3656                _depth
3657            )?;
3658            fidl::decode!(
3659                fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
3660                D,
3661                &mut self.max_path_loss,
3662                decoder,
3663                offset + 64,
3664                _depth
3665            )?;
3666            Ok(())
3667        }
3668    }
3669
3670    impl fidl::encoding::ValueTypeMarker for ScanResultWatcherWatchResponse {
3671        type Borrowed<'a> = &'a Self;
3672        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3673            value
3674        }
3675    }
3676
3677    unsafe impl fidl::encoding::TypeMarker for ScanResultWatcherWatchResponse {
3678        type Owned = Self;
3679
3680        #[inline(always)]
3681        fn inline_align(_context: fidl::encoding::Context) -> usize {
3682            8
3683        }
3684
3685        #[inline(always)]
3686        fn inline_size(_context: fidl::encoding::Context) -> usize {
3687            16
3688        }
3689    }
3690
3691    unsafe impl<D: fidl::encoding::ResourceDialect>
3692        fidl::encoding::Encode<ScanResultWatcherWatchResponse, D>
3693        for &ScanResultWatcherWatchResponse
3694    {
3695        #[inline]
3696        unsafe fn encode(
3697            self,
3698            encoder: &mut fidl::encoding::Encoder<'_, D>,
3699            offset: usize,
3700            _depth: fidl::encoding::Depth,
3701        ) -> fidl::Result<()> {
3702            encoder.debug_check_bounds::<ScanResultWatcherWatchResponse>(offset);
3703            // Delegate to tuple encoding.
3704            fidl::encoding::Encode::<ScanResultWatcherWatchResponse, D>::encode(
3705                (
3706                    <fidl::encoding::UnboundedVector<Peer> as fidl::encoding::ValueTypeMarker>::borrow(&self.updated),
3707                ),
3708                encoder, offset, _depth
3709            )
3710        }
3711    }
3712    unsafe impl<
3713            D: fidl::encoding::ResourceDialect,
3714            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<Peer>, D>,
3715        > fidl::encoding::Encode<ScanResultWatcherWatchResponse, D> for (T0,)
3716    {
3717        #[inline]
3718        unsafe fn encode(
3719            self,
3720            encoder: &mut fidl::encoding::Encoder<'_, D>,
3721            offset: usize,
3722            depth: fidl::encoding::Depth,
3723        ) -> fidl::Result<()> {
3724            encoder.debug_check_bounds::<ScanResultWatcherWatchResponse>(offset);
3725            // Zero out padding regions. There's no need to apply masks
3726            // because the unmasked parts will be overwritten by fields.
3727            // Write the fields.
3728            self.0.encode(encoder, offset + 0, depth)?;
3729            Ok(())
3730        }
3731    }
3732
3733    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3734        for ScanResultWatcherWatchResponse
3735    {
3736        #[inline(always)]
3737        fn new_empty() -> Self {
3738            Self { updated: fidl::new_empty!(fidl::encoding::UnboundedVector<Peer>, D) }
3739        }
3740
3741        #[inline]
3742        unsafe fn decode(
3743            &mut self,
3744            decoder: &mut fidl::encoding::Decoder<'_, D>,
3745            offset: usize,
3746            _depth: fidl::encoding::Depth,
3747        ) -> fidl::Result<()> {
3748            decoder.debug_check_bounds::<Self>(offset);
3749            // Verify that padding bytes are zero.
3750            fidl::decode!(
3751                fidl::encoding::UnboundedVector<Peer>,
3752                D,
3753                &mut self.updated,
3754                decoder,
3755                offset + 0,
3756                _depth
3757            )?;
3758            Ok(())
3759        }
3760    }
3761
3762    impl fidl::encoding::ValueTypeMarker for ServiceData {
3763        type Borrowed<'a> = &'a Self;
3764        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3765            value
3766        }
3767    }
3768
3769    unsafe impl fidl::encoding::TypeMarker for ServiceData {
3770        type Owned = Self;
3771
3772        #[inline(always)]
3773        fn inline_align(_context: fidl::encoding::Context) -> usize {
3774            8
3775        }
3776
3777        #[inline(always)]
3778        fn inline_size(_context: fidl::encoding::Context) -> usize {
3779            32
3780        }
3781    }
3782
3783    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ServiceData, D>
3784        for &ServiceData
3785    {
3786        #[inline]
3787        unsafe fn encode(
3788            self,
3789            encoder: &mut fidl::encoding::Encoder<'_, D>,
3790            offset: usize,
3791            _depth: fidl::encoding::Depth,
3792        ) -> fidl::Result<()> {
3793            encoder.debug_check_bounds::<ServiceData>(offset);
3794            // Delegate to tuple encoding.
3795            fidl::encoding::Encode::<ServiceData, D>::encode(
3796                (
3797                    <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow(&self.uuid),
3798                    <fidl::encoding::Vector<u8, 252> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
3799                ),
3800                encoder, offset, _depth
3801            )
3802        }
3803    }
3804    unsafe impl<
3805            D: fidl::encoding::ResourceDialect,
3806            T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::Uuid, D>,
3807            T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 252>, D>,
3808        > fidl::encoding::Encode<ServiceData, D> for (T0, T1)
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::<ServiceData>(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            Ok(())
3824        }
3825    }
3826
3827    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ServiceData {
3828        #[inline(always)]
3829        fn new_empty() -> Self {
3830            Self {
3831                uuid: fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D),
3832                data: fidl::new_empty!(fidl::encoding::Vector<u8, 252>, D),
3833            }
3834        }
3835
3836        #[inline]
3837        unsafe fn decode(
3838            &mut self,
3839            decoder: &mut fidl::encoding::Decoder<'_, D>,
3840            offset: usize,
3841            _depth: fidl::encoding::Depth,
3842        ) -> fidl::Result<()> {
3843            decoder.debug_check_bounds::<Self>(offset);
3844            // Verify that padding bytes are zero.
3845            fidl::decode!(
3846                fidl_fuchsia_bluetooth__common::Uuid,
3847                D,
3848                &mut self.uuid,
3849                decoder,
3850                offset + 0,
3851                _depth
3852            )?;
3853            fidl::decode!(fidl::encoding::Vector<u8, 252>, D, &mut self.data, decoder, offset + 16, _depth)?;
3854            Ok(())
3855        }
3856    }
3857
3858    impl fidl::encoding::ValueTypeMarker for ServiceDataEntry {
3859        type Borrowed<'a> = &'a Self;
3860        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3861            value
3862        }
3863    }
3864
3865    unsafe impl fidl::encoding::TypeMarker for ServiceDataEntry {
3866        type Owned = Self;
3867
3868        #[inline(always)]
3869        fn inline_align(_context: fidl::encoding::Context) -> usize {
3870            8
3871        }
3872
3873        #[inline(always)]
3874        fn inline_size(_context: fidl::encoding::Context) -> usize {
3875            32
3876        }
3877    }
3878
3879    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ServiceDataEntry, D>
3880        for &ServiceDataEntry
3881    {
3882        #[inline]
3883        unsafe fn encode(
3884            self,
3885            encoder: &mut fidl::encoding::Encoder<'_, D>,
3886            offset: usize,
3887            _depth: fidl::encoding::Depth,
3888        ) -> fidl::Result<()> {
3889            encoder.debug_check_bounds::<ServiceDataEntry>(offset);
3890            // Delegate to tuple encoding.
3891            fidl::encoding::Encode::<ServiceDataEntry, D>::encode(
3892                (
3893                    <fidl::encoding::BoundedString<36> as fidl::encoding::ValueTypeMarker>::borrow(&self.uuid),
3894                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
3895                ),
3896                encoder, offset, _depth
3897            )
3898        }
3899    }
3900    unsafe impl<
3901            D: fidl::encoding::ResourceDialect,
3902            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<36>, D>,
3903            T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
3904        > fidl::encoding::Encode<ServiceDataEntry, D> for (T0, T1)
3905    {
3906        #[inline]
3907        unsafe fn encode(
3908            self,
3909            encoder: &mut fidl::encoding::Encoder<'_, D>,
3910            offset: usize,
3911            depth: fidl::encoding::Depth,
3912        ) -> fidl::Result<()> {
3913            encoder.debug_check_bounds::<ServiceDataEntry>(offset);
3914            // Zero out padding regions. There's no need to apply masks
3915            // because the unmasked parts will be overwritten by fields.
3916            // Write the fields.
3917            self.0.encode(encoder, offset + 0, depth)?;
3918            self.1.encode(encoder, offset + 16, depth)?;
3919            Ok(())
3920        }
3921    }
3922
3923    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ServiceDataEntry {
3924        #[inline(always)]
3925        fn new_empty() -> Self {
3926            Self {
3927                uuid: fidl::new_empty!(fidl::encoding::BoundedString<36>, D),
3928                data: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
3929            }
3930        }
3931
3932        #[inline]
3933        unsafe fn decode(
3934            &mut self,
3935            decoder: &mut fidl::encoding::Decoder<'_, D>,
3936            offset: usize,
3937            _depth: fidl::encoding::Depth,
3938        ) -> fidl::Result<()> {
3939            decoder.debug_check_bounds::<Self>(offset);
3940            // Verify that padding bytes are zero.
3941            fidl::decode!(
3942                fidl::encoding::BoundedString<36>,
3943                D,
3944                &mut self.uuid,
3945                decoder,
3946                offset + 0,
3947                _depth
3948            )?;
3949            fidl::decode!(
3950                fidl::encoding::UnboundedVector<u8>,
3951                D,
3952                &mut self.data,
3953                decoder,
3954                offset + 16,
3955                _depth
3956            )?;
3957            Ok(())
3958        }
3959    }
3960
3961    impl AcceptedChannelParameters {
3962        #[inline(always)]
3963        fn max_ordinal_present(&self) -> u64 {
3964            if let Some(_) = self.max_packet_size {
3965                return 2;
3966            }
3967            if let Some(_) = self.accepted_channel_modes {
3968                return 1;
3969            }
3970            0
3971        }
3972    }
3973
3974    impl fidl::encoding::ValueTypeMarker for AcceptedChannelParameters {
3975        type Borrowed<'a> = &'a Self;
3976        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3977            value
3978        }
3979    }
3980
3981    unsafe impl fidl::encoding::TypeMarker for AcceptedChannelParameters {
3982        type Owned = Self;
3983
3984        #[inline(always)]
3985        fn inline_align(_context: fidl::encoding::Context) -> usize {
3986            8
3987        }
3988
3989        #[inline(always)]
3990        fn inline_size(_context: fidl::encoding::Context) -> usize {
3991            16
3992        }
3993    }
3994
3995    unsafe impl<D: fidl::encoding::ResourceDialect>
3996        fidl::encoding::Encode<AcceptedChannelParameters, D> for &AcceptedChannelParameters
3997    {
3998        unsafe fn encode(
3999            self,
4000            encoder: &mut fidl::encoding::Encoder<'_, D>,
4001            offset: usize,
4002            mut depth: fidl::encoding::Depth,
4003        ) -> fidl::Result<()> {
4004            encoder.debug_check_bounds::<AcceptedChannelParameters>(offset);
4005            // Vector header
4006            let max_ordinal: u64 = self.max_ordinal_present();
4007            encoder.write_num(max_ordinal, offset);
4008            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4009            // Calling encoder.out_of_line_offset(0) is not allowed.
4010            if max_ordinal == 0 {
4011                return Ok(());
4012            }
4013            depth.increment()?;
4014            let envelope_size = 8;
4015            let bytes_len = max_ordinal as usize * envelope_size;
4016            #[allow(unused_variables)]
4017            let offset = encoder.out_of_line_offset(bytes_len);
4018            let mut _prev_end_offset: usize = 0;
4019            if 1 > max_ordinal {
4020                return Ok(());
4021            }
4022
4023            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4024            // are envelope_size bytes.
4025            let cur_offset: usize = (1 - 1) * envelope_size;
4026
4027            // Zero reserved fields.
4028            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4029
4030            // Safety:
4031            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4032            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4033            //   envelope_size bytes, there is always sufficient room.
4034            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::ChannelMode>, D>(
4035            self.accepted_channel_modes.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::ChannelMode> as fidl::encoding::ValueTypeMarker>::borrow),
4036            encoder, offset + cur_offset, depth
4037        )?;
4038
4039            _prev_end_offset = cur_offset + envelope_size;
4040            if 2 > max_ordinal {
4041                return Ok(());
4042            }
4043
4044            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4045            // are envelope_size bytes.
4046            let cur_offset: usize = (2 - 1) * envelope_size;
4047
4048            // Zero reserved fields.
4049            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4050
4051            // Safety:
4052            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4053            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4054            //   envelope_size bytes, there is always sufficient room.
4055            fidl::encoding::encode_in_envelope_optional::<u16, D>(
4056                self.max_packet_size.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4057                encoder,
4058                offset + cur_offset,
4059                depth,
4060            )?;
4061
4062            _prev_end_offset = cur_offset + envelope_size;
4063
4064            Ok(())
4065        }
4066    }
4067
4068    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4069        for AcceptedChannelParameters
4070    {
4071        #[inline(always)]
4072        fn new_empty() -> Self {
4073            Self::default()
4074        }
4075
4076        unsafe fn decode(
4077            &mut self,
4078            decoder: &mut fidl::encoding::Decoder<'_, D>,
4079            offset: usize,
4080            mut depth: fidl::encoding::Depth,
4081        ) -> fidl::Result<()> {
4082            decoder.debug_check_bounds::<Self>(offset);
4083            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4084                None => return Err(fidl::Error::NotNullable),
4085                Some(len) => len,
4086            };
4087            // Calling decoder.out_of_line_offset(0) is not allowed.
4088            if len == 0 {
4089                return Ok(());
4090            };
4091            depth.increment()?;
4092            let envelope_size = 8;
4093            let bytes_len = len * envelope_size;
4094            let offset = decoder.out_of_line_offset(bytes_len)?;
4095            // Decode the envelope for each type.
4096            let mut _next_ordinal_to_read = 0;
4097            let mut next_offset = offset;
4098            let end_offset = offset + bytes_len;
4099            _next_ordinal_to_read += 1;
4100            if next_offset >= end_offset {
4101                return Ok(());
4102            }
4103
4104            // Decode unknown envelopes for gaps in ordinals.
4105            while _next_ordinal_to_read < 1 {
4106                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4107                _next_ordinal_to_read += 1;
4108                next_offset += envelope_size;
4109            }
4110
4111            let next_out_of_line = decoder.next_out_of_line();
4112            let handles_before = decoder.remaining_handles();
4113            if let Some((inlined, num_bytes, num_handles)) =
4114                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4115            {
4116                let member_inline_size = <fidl::encoding::UnboundedVector<
4117                    fidl_fuchsia_bluetooth__common::ChannelMode,
4118                > as fidl::encoding::TypeMarker>::inline_size(
4119                    decoder.context
4120                );
4121                if inlined != (member_inline_size <= 4) {
4122                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4123                }
4124                let inner_offset;
4125                let mut inner_depth = depth.clone();
4126                if inlined {
4127                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4128                    inner_offset = next_offset;
4129                } else {
4130                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4131                    inner_depth.increment()?;
4132                }
4133                let val_ref = self.accepted_channel_modes.get_or_insert_with(|| {
4134                    fidl::new_empty!(
4135                        fidl::encoding::UnboundedVector<
4136                            fidl_fuchsia_bluetooth__common::ChannelMode,
4137                        >,
4138                        D
4139                    )
4140                });
4141                fidl::decode!(
4142                    fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::ChannelMode>,
4143                    D,
4144                    val_ref,
4145                    decoder,
4146                    inner_offset,
4147                    inner_depth
4148                )?;
4149                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4150                {
4151                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4152                }
4153                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4154                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4155                }
4156            }
4157
4158            next_offset += envelope_size;
4159            _next_ordinal_to_read += 1;
4160            if next_offset >= end_offset {
4161                return Ok(());
4162            }
4163
4164            // Decode unknown envelopes for gaps in ordinals.
4165            while _next_ordinal_to_read < 2 {
4166                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4167                _next_ordinal_to_read += 1;
4168                next_offset += envelope_size;
4169            }
4170
4171            let next_out_of_line = decoder.next_out_of_line();
4172            let handles_before = decoder.remaining_handles();
4173            if let Some((inlined, num_bytes, num_handles)) =
4174                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4175            {
4176                let member_inline_size =
4177                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4178                if inlined != (member_inline_size <= 4) {
4179                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4180                }
4181                let inner_offset;
4182                let mut inner_depth = depth.clone();
4183                if inlined {
4184                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4185                    inner_offset = next_offset;
4186                } else {
4187                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4188                    inner_depth.increment()?;
4189                }
4190                let val_ref = self.max_packet_size.get_or_insert_with(|| fidl::new_empty!(u16, D));
4191                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4192                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4193                {
4194                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4195                }
4196                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4197                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4198                }
4199            }
4200
4201            next_offset += envelope_size;
4202
4203            // Decode the remaining unknown envelopes.
4204            while next_offset < end_offset {
4205                _next_ordinal_to_read += 1;
4206                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4207                next_offset += envelope_size;
4208            }
4209
4210            Ok(())
4211        }
4212    }
4213
4214    impl AdvertisingData {
4215        #[inline(always)]
4216        fn max_ordinal_present(&self) -> u64 {
4217            if let Some(_) = self.broadcast_name {
4218                return 10;
4219            }
4220            if let Some(_) = self.resolvable_set_identifier {
4221                return 9;
4222            }
4223            if let Some(_) = self.include_tx_power_level {
4224                return 8;
4225            }
4226            if let Some(_) = self.uris {
4227                return 7;
4228            }
4229            if let Some(_) = self.manufacturer_data {
4230                return 6;
4231            }
4232            if let Some(_) = self.service_data {
4233                return 5;
4234            }
4235            if let Some(_) = self.service_uuids {
4236                return 4;
4237            }
4238            if let Some(_) = self.tx_power_level {
4239                return 3;
4240            }
4241            if let Some(_) = self.appearance {
4242                return 2;
4243            }
4244            if let Some(_) = self.name {
4245                return 1;
4246            }
4247            0
4248        }
4249    }
4250
4251    impl fidl::encoding::ValueTypeMarker for AdvertisingData {
4252        type Borrowed<'a> = &'a Self;
4253        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4254            value
4255        }
4256    }
4257
4258    unsafe impl fidl::encoding::TypeMarker for AdvertisingData {
4259        type Owned = Self;
4260
4261        #[inline(always)]
4262        fn inline_align(_context: fidl::encoding::Context) -> usize {
4263            8
4264        }
4265
4266        #[inline(always)]
4267        fn inline_size(_context: fidl::encoding::Context) -> usize {
4268            16
4269        }
4270    }
4271
4272    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AdvertisingData, D>
4273        for &AdvertisingData
4274    {
4275        unsafe fn encode(
4276            self,
4277            encoder: &mut fidl::encoding::Encoder<'_, D>,
4278            offset: usize,
4279            mut depth: fidl::encoding::Depth,
4280        ) -> fidl::Result<()> {
4281            encoder.debug_check_bounds::<AdvertisingData>(offset);
4282            // Vector header
4283            let max_ordinal: u64 = self.max_ordinal_present();
4284            encoder.write_num(max_ordinal, offset);
4285            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4286            // Calling encoder.out_of_line_offset(0) is not allowed.
4287            if max_ordinal == 0 {
4288                return Ok(());
4289            }
4290            depth.increment()?;
4291            let envelope_size = 8;
4292            let bytes_len = max_ordinal as usize * envelope_size;
4293            #[allow(unused_variables)]
4294            let offset = encoder.out_of_line_offset(bytes_len);
4295            let mut _prev_end_offset: usize = 0;
4296            if 1 > max_ordinal {
4297                return Ok(());
4298            }
4299
4300            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4301            // are envelope_size bytes.
4302            let cur_offset: usize = (1 - 1) * envelope_size;
4303
4304            // Zero reserved fields.
4305            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4306
4307            // Safety:
4308            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4309            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4310            //   envelope_size bytes, there is always sufficient room.
4311            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<248>, D>(
4312                self.name.as_ref().map(
4313                    <fidl::encoding::BoundedString<248> as fidl::encoding::ValueTypeMarker>::borrow,
4314                ),
4315                encoder,
4316                offset + cur_offset,
4317                depth,
4318            )?;
4319
4320            _prev_end_offset = cur_offset + envelope_size;
4321            if 2 > max_ordinal {
4322                return Ok(());
4323            }
4324
4325            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4326            // are envelope_size bytes.
4327            let cur_offset: usize = (2 - 1) * envelope_size;
4328
4329            // Zero reserved fields.
4330            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4331
4332            // Safety:
4333            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4334            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4335            //   envelope_size bytes, there is always sufficient room.
4336            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Appearance, D>(
4337            self.appearance.as_ref().map(<fidl_fuchsia_bluetooth__common::Appearance as fidl::encoding::ValueTypeMarker>::borrow),
4338            encoder, offset + cur_offset, depth
4339        )?;
4340
4341            _prev_end_offset = cur_offset + envelope_size;
4342            if 3 > max_ordinal {
4343                return Ok(());
4344            }
4345
4346            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4347            // are envelope_size bytes.
4348            let cur_offset: usize = (3 - 1) * envelope_size;
4349
4350            // Zero reserved fields.
4351            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4352
4353            // Safety:
4354            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4355            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4356            //   envelope_size bytes, there is always sufficient room.
4357            fidl::encoding::encode_in_envelope_optional::<i8, D>(
4358                self.tx_power_level.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
4359                encoder,
4360                offset + cur_offset,
4361                depth,
4362            )?;
4363
4364            _prev_end_offset = cur_offset + envelope_size;
4365            if 4 > max_ordinal {
4366                return Ok(());
4367            }
4368
4369            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4370            // are envelope_size bytes.
4371            let cur_offset: usize = (4 - 1) * envelope_size;
4372
4373            // Zero reserved fields.
4374            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4375
4376            // Safety:
4377            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4378            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4379            //   envelope_size bytes, there is always sufficient room.
4380            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>, D>(
4381            self.service_uuids.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid> as fidl::encoding::ValueTypeMarker>::borrow),
4382            encoder, offset + cur_offset, depth
4383        )?;
4384
4385            _prev_end_offset = cur_offset + envelope_size;
4386            if 5 > max_ordinal {
4387                return Ok(());
4388            }
4389
4390            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4391            // are envelope_size bytes.
4392            let cur_offset: usize = (5 - 1) * envelope_size;
4393
4394            // Zero reserved fields.
4395            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4396
4397            // Safety:
4398            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4399            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4400            //   envelope_size bytes, there is always sufficient room.
4401            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ServiceData>, D>(
4402            self.service_data.as_ref().map(<fidl::encoding::UnboundedVector<ServiceData> as fidl::encoding::ValueTypeMarker>::borrow),
4403            encoder, offset + cur_offset, depth
4404        )?;
4405
4406            _prev_end_offset = cur_offset + envelope_size;
4407            if 6 > max_ordinal {
4408                return Ok(());
4409            }
4410
4411            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4412            // are envelope_size bytes.
4413            let cur_offset: usize = (6 - 1) * envelope_size;
4414
4415            // Zero reserved fields.
4416            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4417
4418            // Safety:
4419            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4420            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4421            //   envelope_size bytes, there is always sufficient room.
4422            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ManufacturerData>, D>(
4423            self.manufacturer_data.as_ref().map(<fidl::encoding::UnboundedVector<ManufacturerData> as fidl::encoding::ValueTypeMarker>::borrow),
4424            encoder, offset + cur_offset, depth
4425        )?;
4426
4427            _prev_end_offset = cur_offset + envelope_size;
4428            if 7 > max_ordinal {
4429                return Ok(());
4430            }
4431
4432            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4433            // are envelope_size bytes.
4434            let cur_offset: usize = (7 - 1) * envelope_size;
4435
4436            // Zero reserved fields.
4437            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4438
4439            // Safety:
4440            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4441            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4442            //   envelope_size bytes, there is always sufficient room.
4443            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>, D>(
4444            self.uris.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>> as fidl::encoding::ValueTypeMarker>::borrow),
4445            encoder, offset + cur_offset, depth
4446        )?;
4447
4448            _prev_end_offset = cur_offset + envelope_size;
4449            if 8 > max_ordinal {
4450                return Ok(());
4451            }
4452
4453            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4454            // are envelope_size bytes.
4455            let cur_offset: usize = (8 - 1) * envelope_size;
4456
4457            // Zero reserved fields.
4458            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4459
4460            // Safety:
4461            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4462            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4463            //   envelope_size bytes, there is always sufficient room.
4464            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4465                self.include_tx_power_level
4466                    .as_ref()
4467                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4468                encoder,
4469                offset + cur_offset,
4470                depth,
4471            )?;
4472
4473            _prev_end_offset = cur_offset + envelope_size;
4474            if 9 > max_ordinal {
4475                return Ok(());
4476            }
4477
4478            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4479            // are envelope_size bytes.
4480            let cur_offset: usize = (9 - 1) * envelope_size;
4481
4482            // Zero reserved fields.
4483            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4484
4485            // Safety:
4486            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4487            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4488            //   envelope_size bytes, there is always sufficient room.
4489            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
4490                self.resolvable_set_identifier
4491                    .as_ref()
4492                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
4493                encoder,
4494                offset + cur_offset,
4495                depth,
4496            )?;
4497
4498            _prev_end_offset = cur_offset + envelope_size;
4499            if 10 > max_ordinal {
4500                return Ok(());
4501            }
4502
4503            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4504            // are envelope_size bytes.
4505            let cur_offset: usize = (10 - 1) * envelope_size;
4506
4507            // Zero reserved fields.
4508            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4509
4510            // Safety:
4511            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4512            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4513            //   envelope_size bytes, there is always sufficient room.
4514            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<128>, D>(
4515                self.broadcast_name.as_ref().map(
4516                    <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow,
4517                ),
4518                encoder,
4519                offset + cur_offset,
4520                depth,
4521            )?;
4522
4523            _prev_end_offset = cur_offset + envelope_size;
4524
4525            Ok(())
4526        }
4527    }
4528
4529    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvertisingData {
4530        #[inline(always)]
4531        fn new_empty() -> Self {
4532            Self::default()
4533        }
4534
4535        unsafe fn decode(
4536            &mut self,
4537            decoder: &mut fidl::encoding::Decoder<'_, D>,
4538            offset: usize,
4539            mut depth: fidl::encoding::Depth,
4540        ) -> fidl::Result<()> {
4541            decoder.debug_check_bounds::<Self>(offset);
4542            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4543                None => return Err(fidl::Error::NotNullable),
4544                Some(len) => len,
4545            };
4546            // Calling decoder.out_of_line_offset(0) is not allowed.
4547            if len == 0 {
4548                return Ok(());
4549            };
4550            depth.increment()?;
4551            let envelope_size = 8;
4552            let bytes_len = len * envelope_size;
4553            let offset = decoder.out_of_line_offset(bytes_len)?;
4554            // Decode the envelope for each type.
4555            let mut _next_ordinal_to_read = 0;
4556            let mut next_offset = offset;
4557            let end_offset = offset + bytes_len;
4558            _next_ordinal_to_read += 1;
4559            if next_offset >= end_offset {
4560                return Ok(());
4561            }
4562
4563            // Decode unknown envelopes for gaps in ordinals.
4564            while _next_ordinal_to_read < 1 {
4565                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4566                _next_ordinal_to_read += 1;
4567                next_offset += envelope_size;
4568            }
4569
4570            let next_out_of_line = decoder.next_out_of_line();
4571            let handles_before = decoder.remaining_handles();
4572            if let Some((inlined, num_bytes, num_handles)) =
4573                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4574            {
4575                let member_inline_size =
4576                    <fidl::encoding::BoundedString<248> as fidl::encoding::TypeMarker>::inline_size(
4577                        decoder.context,
4578                    );
4579                if inlined != (member_inline_size <= 4) {
4580                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4581                }
4582                let inner_offset;
4583                let mut inner_depth = depth.clone();
4584                if inlined {
4585                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4586                    inner_offset = next_offset;
4587                } else {
4588                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4589                    inner_depth.increment()?;
4590                }
4591                let val_ref = self
4592                    .name
4593                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<248>, D));
4594                fidl::decode!(
4595                    fidl::encoding::BoundedString<248>,
4596                    D,
4597                    val_ref,
4598                    decoder,
4599                    inner_offset,
4600                    inner_depth
4601                )?;
4602                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4603                {
4604                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4605                }
4606                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4607                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4608                }
4609            }
4610
4611            next_offset += envelope_size;
4612            _next_ordinal_to_read += 1;
4613            if next_offset >= end_offset {
4614                return Ok(());
4615            }
4616
4617            // Decode unknown envelopes for gaps in ordinals.
4618            while _next_ordinal_to_read < 2 {
4619                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4620                _next_ordinal_to_read += 1;
4621                next_offset += envelope_size;
4622            }
4623
4624            let next_out_of_line = decoder.next_out_of_line();
4625            let handles_before = decoder.remaining_handles();
4626            if let Some((inlined, num_bytes, num_handles)) =
4627                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4628            {
4629                let member_inline_size = <fidl_fuchsia_bluetooth__common::Appearance as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4630                if inlined != (member_inline_size <= 4) {
4631                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4632                }
4633                let inner_offset;
4634                let mut inner_depth = depth.clone();
4635                if inlined {
4636                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4637                    inner_offset = next_offset;
4638                } else {
4639                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4640                    inner_depth.increment()?;
4641                }
4642                let val_ref = self.appearance.get_or_insert_with(|| {
4643                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::Appearance, D)
4644                });
4645                fidl::decode!(
4646                    fidl_fuchsia_bluetooth__common::Appearance,
4647                    D,
4648                    val_ref,
4649                    decoder,
4650                    inner_offset,
4651                    inner_depth
4652                )?;
4653                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4654                {
4655                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4656                }
4657                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4658                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4659                }
4660            }
4661
4662            next_offset += envelope_size;
4663            _next_ordinal_to_read += 1;
4664            if next_offset >= end_offset {
4665                return Ok(());
4666            }
4667
4668            // Decode unknown envelopes for gaps in ordinals.
4669            while _next_ordinal_to_read < 3 {
4670                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4671                _next_ordinal_to_read += 1;
4672                next_offset += envelope_size;
4673            }
4674
4675            let next_out_of_line = decoder.next_out_of_line();
4676            let handles_before = decoder.remaining_handles();
4677            if let Some((inlined, num_bytes, num_handles)) =
4678                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4679            {
4680                let member_inline_size =
4681                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4682                if inlined != (member_inline_size <= 4) {
4683                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4684                }
4685                let inner_offset;
4686                let mut inner_depth = depth.clone();
4687                if inlined {
4688                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4689                    inner_offset = next_offset;
4690                } else {
4691                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4692                    inner_depth.increment()?;
4693                }
4694                let val_ref = self.tx_power_level.get_or_insert_with(|| fidl::new_empty!(i8, D));
4695                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
4696                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4697                {
4698                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4699                }
4700                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4701                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4702                }
4703            }
4704
4705            next_offset += envelope_size;
4706            _next_ordinal_to_read += 1;
4707            if next_offset >= end_offset {
4708                return Ok(());
4709            }
4710
4711            // Decode unknown envelopes for gaps in ordinals.
4712            while _next_ordinal_to_read < 4 {
4713                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4714                _next_ordinal_to_read += 1;
4715                next_offset += envelope_size;
4716            }
4717
4718            let next_out_of_line = decoder.next_out_of_line();
4719            let handles_before = decoder.remaining_handles();
4720            if let Some((inlined, num_bytes, num_handles)) =
4721                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4722            {
4723                let member_inline_size = <fidl::encoding::UnboundedVector<
4724                    fidl_fuchsia_bluetooth__common::Uuid,
4725                > as fidl::encoding::TypeMarker>::inline_size(
4726                    decoder.context
4727                );
4728                if inlined != (member_inline_size <= 4) {
4729                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4730                }
4731                let inner_offset;
4732                let mut inner_depth = depth.clone();
4733                if inlined {
4734                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4735                    inner_offset = next_offset;
4736                } else {
4737                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4738                    inner_depth.increment()?;
4739                }
4740                let val_ref = self.service_uuids.get_or_insert_with(|| {
4741                    fidl::new_empty!(
4742                        fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>,
4743                        D
4744                    )
4745                });
4746                fidl::decode!(
4747                    fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>,
4748                    D,
4749                    val_ref,
4750                    decoder,
4751                    inner_offset,
4752                    inner_depth
4753                )?;
4754                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4755                {
4756                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4757                }
4758                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4759                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4760                }
4761            }
4762
4763            next_offset += envelope_size;
4764            _next_ordinal_to_read += 1;
4765            if next_offset >= end_offset {
4766                return Ok(());
4767            }
4768
4769            // Decode unknown envelopes for gaps in ordinals.
4770            while _next_ordinal_to_read < 5 {
4771                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4772                _next_ordinal_to_read += 1;
4773                next_offset += envelope_size;
4774            }
4775
4776            let next_out_of_line = decoder.next_out_of_line();
4777            let handles_before = decoder.remaining_handles();
4778            if let Some((inlined, num_bytes, num_handles)) =
4779                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4780            {
4781                let member_inline_size = <fidl::encoding::UnboundedVector<ServiceData> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4782                if inlined != (member_inline_size <= 4) {
4783                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4784                }
4785                let inner_offset;
4786                let mut inner_depth = depth.clone();
4787                if inlined {
4788                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4789                    inner_offset = next_offset;
4790                } else {
4791                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4792                    inner_depth.increment()?;
4793                }
4794                let val_ref = self.service_data.get_or_insert_with(|| {
4795                    fidl::new_empty!(fidl::encoding::UnboundedVector<ServiceData>, D)
4796                });
4797                fidl::decode!(
4798                    fidl::encoding::UnboundedVector<ServiceData>,
4799                    D,
4800                    val_ref,
4801                    decoder,
4802                    inner_offset,
4803                    inner_depth
4804                )?;
4805                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4806                {
4807                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4808                }
4809                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4810                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4811                }
4812            }
4813
4814            next_offset += envelope_size;
4815            _next_ordinal_to_read += 1;
4816            if next_offset >= end_offset {
4817                return Ok(());
4818            }
4819
4820            // Decode unknown envelopes for gaps in ordinals.
4821            while _next_ordinal_to_read < 6 {
4822                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4823                _next_ordinal_to_read += 1;
4824                next_offset += envelope_size;
4825            }
4826
4827            let next_out_of_line = decoder.next_out_of_line();
4828            let handles_before = decoder.remaining_handles();
4829            if let Some((inlined, num_bytes, num_handles)) =
4830                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4831            {
4832                let member_inline_size = <fidl::encoding::UnboundedVector<ManufacturerData> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4833                if inlined != (member_inline_size <= 4) {
4834                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4835                }
4836                let inner_offset;
4837                let mut inner_depth = depth.clone();
4838                if inlined {
4839                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4840                    inner_offset = next_offset;
4841                } else {
4842                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4843                    inner_depth.increment()?;
4844                }
4845                let val_ref = self.manufacturer_data.get_or_insert_with(|| {
4846                    fidl::new_empty!(fidl::encoding::UnboundedVector<ManufacturerData>, D)
4847                });
4848                fidl::decode!(
4849                    fidl::encoding::UnboundedVector<ManufacturerData>,
4850                    D,
4851                    val_ref,
4852                    decoder,
4853                    inner_offset,
4854                    inner_depth
4855                )?;
4856                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4857                {
4858                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4859                }
4860                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4861                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4862                }
4863            }
4864
4865            next_offset += envelope_size;
4866            _next_ordinal_to_read += 1;
4867            if next_offset >= end_offset {
4868                return Ok(());
4869            }
4870
4871            // Decode unknown envelopes for gaps in ordinals.
4872            while _next_ordinal_to_read < 7 {
4873                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4874                _next_ordinal_to_read += 1;
4875                next_offset += envelope_size;
4876            }
4877
4878            let next_out_of_line = decoder.next_out_of_line();
4879            let handles_before = decoder.remaining_handles();
4880            if let Some((inlined, num_bytes, num_handles)) =
4881                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4882            {
4883                let member_inline_size = <fidl::encoding::UnboundedVector<
4884                    fidl::encoding::BoundedString<278>,
4885                > as fidl::encoding::TypeMarker>::inline_size(
4886                    decoder.context
4887                );
4888                if inlined != (member_inline_size <= 4) {
4889                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4890                }
4891                let inner_offset;
4892                let mut inner_depth = depth.clone();
4893                if inlined {
4894                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4895                    inner_offset = next_offset;
4896                } else {
4897                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4898                    inner_depth.increment()?;
4899                }
4900                let val_ref = self.uris.get_or_insert_with(|| {
4901                    fidl::new_empty!(
4902                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>,
4903                        D
4904                    )
4905                });
4906                fidl::decode!(
4907                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>,
4908                    D,
4909                    val_ref,
4910                    decoder,
4911                    inner_offset,
4912                    inner_depth
4913                )?;
4914                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4915                {
4916                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4917                }
4918                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4919                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4920                }
4921            }
4922
4923            next_offset += envelope_size;
4924            _next_ordinal_to_read += 1;
4925            if next_offset >= end_offset {
4926                return Ok(());
4927            }
4928
4929            // Decode unknown envelopes for gaps in ordinals.
4930            while _next_ordinal_to_read < 8 {
4931                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4932                _next_ordinal_to_read += 1;
4933                next_offset += envelope_size;
4934            }
4935
4936            let next_out_of_line = decoder.next_out_of_line();
4937            let handles_before = decoder.remaining_handles();
4938            if let Some((inlined, num_bytes, num_handles)) =
4939                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4940            {
4941                let member_inline_size =
4942                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4943                if inlined != (member_inline_size <= 4) {
4944                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4945                }
4946                let inner_offset;
4947                let mut inner_depth = depth.clone();
4948                if inlined {
4949                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4950                    inner_offset = next_offset;
4951                } else {
4952                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4953                    inner_depth.increment()?;
4954                }
4955                let val_ref =
4956                    self.include_tx_power_level.get_or_insert_with(|| fidl::new_empty!(bool, D));
4957                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4958                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4959                {
4960                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4961                }
4962                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4963                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4964                }
4965            }
4966
4967            next_offset += envelope_size;
4968            _next_ordinal_to_read += 1;
4969            if next_offset >= end_offset {
4970                return Ok(());
4971            }
4972
4973            // Decode unknown envelopes for gaps in ordinals.
4974            while _next_ordinal_to_read < 9 {
4975                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4976                _next_ordinal_to_read += 1;
4977                next_offset += envelope_size;
4978            }
4979
4980            let next_out_of_line = decoder.next_out_of_line();
4981            let handles_before = decoder.remaining_handles();
4982            if let Some((inlined, num_bytes, num_handles)) =
4983                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4984            {
4985                let member_inline_size =
4986                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
4987                        decoder.context,
4988                    );
4989                if inlined != (member_inline_size <= 4) {
4990                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4991                }
4992                let inner_offset;
4993                let mut inner_depth = depth.clone();
4994                if inlined {
4995                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4996                    inner_offset = next_offset;
4997                } else {
4998                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4999                    inner_depth.increment()?;
5000                }
5001                let val_ref = self
5002                    .resolvable_set_identifier
5003                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
5004                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
5005                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5006                {
5007                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5008                }
5009                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5010                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5011                }
5012            }
5013
5014            next_offset += envelope_size;
5015            _next_ordinal_to_read += 1;
5016            if next_offset >= end_offset {
5017                return Ok(());
5018            }
5019
5020            // Decode unknown envelopes for gaps in ordinals.
5021            while _next_ordinal_to_read < 10 {
5022                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5023                _next_ordinal_to_read += 1;
5024                next_offset += envelope_size;
5025            }
5026
5027            let next_out_of_line = decoder.next_out_of_line();
5028            let handles_before = decoder.remaining_handles();
5029            if let Some((inlined, num_bytes, num_handles)) =
5030                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5031            {
5032                let member_inline_size =
5033                    <fidl::encoding::BoundedString<128> as fidl::encoding::TypeMarker>::inline_size(
5034                        decoder.context,
5035                    );
5036                if inlined != (member_inline_size <= 4) {
5037                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5038                }
5039                let inner_offset;
5040                let mut inner_depth = depth.clone();
5041                if inlined {
5042                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5043                    inner_offset = next_offset;
5044                } else {
5045                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5046                    inner_depth.increment()?;
5047                }
5048                let val_ref = self
5049                    .broadcast_name
5050                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<128>, D));
5051                fidl::decode!(
5052                    fidl::encoding::BoundedString<128>,
5053                    D,
5054                    val_ref,
5055                    decoder,
5056                    inner_offset,
5057                    inner_depth
5058                )?;
5059                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5060                {
5061                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5062                }
5063                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5064                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5065                }
5066            }
5067
5068            next_offset += envelope_size;
5069
5070            // Decode the remaining unknown envelopes.
5071            while next_offset < end_offset {
5072                _next_ordinal_to_read += 1;
5073                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5074                next_offset += envelope_size;
5075            }
5076
5077            Ok(())
5078        }
5079    }
5080
5081    impl AdvertisingParameters {
5082        #[inline(always)]
5083        fn max_ordinal_present(&self) -> u64 {
5084            if let Some(_) = self.address_type {
5085                return 7;
5086            }
5087            if let Some(_) = self.advertising_procedure {
5088                return 6;
5089            }
5090            if let Some(_) = self.connection_options {
5091                return 5;
5092            }
5093            if let Some(_) = self.connectable {
5094                return 4;
5095            }
5096            if let Some(_) = self.mode_hint {
5097                return 3;
5098            }
5099            if let Some(_) = self.scan_response {
5100                return 2;
5101            }
5102            if let Some(_) = self.data {
5103                return 1;
5104            }
5105            0
5106        }
5107    }
5108
5109    impl fidl::encoding::ValueTypeMarker for AdvertisingParameters {
5110        type Borrowed<'a> = &'a Self;
5111        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5112            value
5113        }
5114    }
5115
5116    unsafe impl fidl::encoding::TypeMarker for AdvertisingParameters {
5117        type Owned = Self;
5118
5119        #[inline(always)]
5120        fn inline_align(_context: fidl::encoding::Context) -> usize {
5121            8
5122        }
5123
5124        #[inline(always)]
5125        fn inline_size(_context: fidl::encoding::Context) -> usize {
5126            16
5127        }
5128    }
5129
5130    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AdvertisingParameters, D>
5131        for &AdvertisingParameters
5132    {
5133        unsafe fn encode(
5134            self,
5135            encoder: &mut fidl::encoding::Encoder<'_, D>,
5136            offset: usize,
5137            mut depth: fidl::encoding::Depth,
5138        ) -> fidl::Result<()> {
5139            encoder.debug_check_bounds::<AdvertisingParameters>(offset);
5140            // Vector header
5141            let max_ordinal: u64 = self.max_ordinal_present();
5142            encoder.write_num(max_ordinal, offset);
5143            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5144            // Calling encoder.out_of_line_offset(0) is not allowed.
5145            if max_ordinal == 0 {
5146                return Ok(());
5147            }
5148            depth.increment()?;
5149            let envelope_size = 8;
5150            let bytes_len = max_ordinal as usize * envelope_size;
5151            #[allow(unused_variables)]
5152            let offset = encoder.out_of_line_offset(bytes_len);
5153            let mut _prev_end_offset: usize = 0;
5154            if 1 > max_ordinal {
5155                return Ok(());
5156            }
5157
5158            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5159            // are envelope_size bytes.
5160            let cur_offset: usize = (1 - 1) * envelope_size;
5161
5162            // Zero reserved fields.
5163            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5164
5165            // Safety:
5166            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5167            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5168            //   envelope_size bytes, there is always sufficient room.
5169            fidl::encoding::encode_in_envelope_optional::<AdvertisingData, D>(
5170                self.data
5171                    .as_ref()
5172                    .map(<AdvertisingData as fidl::encoding::ValueTypeMarker>::borrow),
5173                encoder,
5174                offset + cur_offset,
5175                depth,
5176            )?;
5177
5178            _prev_end_offset = cur_offset + envelope_size;
5179            if 2 > max_ordinal {
5180                return Ok(());
5181            }
5182
5183            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5184            // are envelope_size bytes.
5185            let cur_offset: usize = (2 - 1) * envelope_size;
5186
5187            // Zero reserved fields.
5188            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5189
5190            // Safety:
5191            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5192            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5193            //   envelope_size bytes, there is always sufficient room.
5194            fidl::encoding::encode_in_envelope_optional::<AdvertisingData, D>(
5195                self.scan_response
5196                    .as_ref()
5197                    .map(<AdvertisingData as fidl::encoding::ValueTypeMarker>::borrow),
5198                encoder,
5199                offset + cur_offset,
5200                depth,
5201            )?;
5202
5203            _prev_end_offset = cur_offset + envelope_size;
5204            if 3 > max_ordinal {
5205                return Ok(());
5206            }
5207
5208            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5209            // are envelope_size bytes.
5210            let cur_offset: usize = (3 - 1) * envelope_size;
5211
5212            // Zero reserved fields.
5213            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5214
5215            // Safety:
5216            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5217            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5218            //   envelope_size bytes, there is always sufficient room.
5219            fidl::encoding::encode_in_envelope_optional::<AdvertisingModeHint, D>(
5220                self.mode_hint
5221                    .as_ref()
5222                    .map(<AdvertisingModeHint as fidl::encoding::ValueTypeMarker>::borrow),
5223                encoder,
5224                offset + cur_offset,
5225                depth,
5226            )?;
5227
5228            _prev_end_offset = cur_offset + envelope_size;
5229            if 4 > max_ordinal {
5230                return Ok(());
5231            }
5232
5233            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5234            // are envelope_size bytes.
5235            let cur_offset: usize = (4 - 1) * envelope_size;
5236
5237            // Zero reserved fields.
5238            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5239
5240            // Safety:
5241            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5242            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5243            //   envelope_size bytes, there is always sufficient room.
5244            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5245                self.connectable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5246                encoder,
5247                offset + cur_offset,
5248                depth,
5249            )?;
5250
5251            _prev_end_offset = cur_offset + envelope_size;
5252            if 5 > max_ordinal {
5253                return Ok(());
5254            }
5255
5256            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5257            // are envelope_size bytes.
5258            let cur_offset: usize = (5 - 1) * envelope_size;
5259
5260            // Zero reserved fields.
5261            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5262
5263            // Safety:
5264            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5265            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5266            //   envelope_size bytes, there is always sufficient room.
5267            fidl::encoding::encode_in_envelope_optional::<ConnectionOptions, D>(
5268                self.connection_options
5269                    .as_ref()
5270                    .map(<ConnectionOptions as fidl::encoding::ValueTypeMarker>::borrow),
5271                encoder,
5272                offset + cur_offset,
5273                depth,
5274            )?;
5275
5276            _prev_end_offset = cur_offset + envelope_size;
5277            if 6 > max_ordinal {
5278                return Ok(());
5279            }
5280
5281            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5282            // are envelope_size bytes.
5283            let cur_offset: usize = (6 - 1) * envelope_size;
5284
5285            // Zero reserved fields.
5286            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5287
5288            // Safety:
5289            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5290            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5291            //   envelope_size bytes, there is always sufficient room.
5292            fidl::encoding::encode_in_envelope_optional::<AdvertisingProcedure, D>(
5293                self.advertising_procedure
5294                    .as_ref()
5295                    .map(<AdvertisingProcedure as fidl::encoding::ValueTypeMarker>::borrow),
5296                encoder,
5297                offset + cur_offset,
5298                depth,
5299            )?;
5300
5301            _prev_end_offset = cur_offset + envelope_size;
5302            if 7 > max_ordinal {
5303                return Ok(());
5304            }
5305
5306            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5307            // are envelope_size bytes.
5308            let cur_offset: usize = (7 - 1) * envelope_size;
5309
5310            // Zero reserved fields.
5311            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5312
5313            // Safety:
5314            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5315            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5316            //   envelope_size bytes, there is always sufficient room.
5317            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::AddressType, D>(
5318            self.address_type.as_ref().map(<fidl_fuchsia_bluetooth__common::AddressType as fidl::encoding::ValueTypeMarker>::borrow),
5319            encoder, offset + cur_offset, depth
5320        )?;
5321
5322            _prev_end_offset = cur_offset + envelope_size;
5323
5324            Ok(())
5325        }
5326    }
5327
5328    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvertisingParameters {
5329        #[inline(always)]
5330        fn new_empty() -> Self {
5331            Self::default()
5332        }
5333
5334        unsafe fn decode(
5335            &mut self,
5336            decoder: &mut fidl::encoding::Decoder<'_, D>,
5337            offset: usize,
5338            mut depth: fidl::encoding::Depth,
5339        ) -> fidl::Result<()> {
5340            decoder.debug_check_bounds::<Self>(offset);
5341            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5342                None => return Err(fidl::Error::NotNullable),
5343                Some(len) => len,
5344            };
5345            // Calling decoder.out_of_line_offset(0) is not allowed.
5346            if len == 0 {
5347                return Ok(());
5348            };
5349            depth.increment()?;
5350            let envelope_size = 8;
5351            let bytes_len = len * envelope_size;
5352            let offset = decoder.out_of_line_offset(bytes_len)?;
5353            // Decode the envelope for each type.
5354            let mut _next_ordinal_to_read = 0;
5355            let mut next_offset = offset;
5356            let end_offset = offset + bytes_len;
5357            _next_ordinal_to_read += 1;
5358            if next_offset >= end_offset {
5359                return Ok(());
5360            }
5361
5362            // Decode unknown envelopes for gaps in ordinals.
5363            while _next_ordinal_to_read < 1 {
5364                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5365                _next_ordinal_to_read += 1;
5366                next_offset += envelope_size;
5367            }
5368
5369            let next_out_of_line = decoder.next_out_of_line();
5370            let handles_before = decoder.remaining_handles();
5371            if let Some((inlined, num_bytes, num_handles)) =
5372                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5373            {
5374                let member_inline_size =
5375                    <AdvertisingData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5376                if inlined != (member_inline_size <= 4) {
5377                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5378                }
5379                let inner_offset;
5380                let mut inner_depth = depth.clone();
5381                if inlined {
5382                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5383                    inner_offset = next_offset;
5384                } else {
5385                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5386                    inner_depth.increment()?;
5387                }
5388                let val_ref = self.data.get_or_insert_with(|| fidl::new_empty!(AdvertisingData, D));
5389                fidl::decode!(AdvertisingData, D, val_ref, decoder, inner_offset, inner_depth)?;
5390                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5391                {
5392                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5393                }
5394                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5395                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5396                }
5397            }
5398
5399            next_offset += envelope_size;
5400            _next_ordinal_to_read += 1;
5401            if next_offset >= end_offset {
5402                return Ok(());
5403            }
5404
5405            // Decode unknown envelopes for gaps in ordinals.
5406            while _next_ordinal_to_read < 2 {
5407                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5408                _next_ordinal_to_read += 1;
5409                next_offset += envelope_size;
5410            }
5411
5412            let next_out_of_line = decoder.next_out_of_line();
5413            let handles_before = decoder.remaining_handles();
5414            if let Some((inlined, num_bytes, num_handles)) =
5415                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5416            {
5417                let member_inline_size =
5418                    <AdvertisingData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5419                if inlined != (member_inline_size <= 4) {
5420                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5421                }
5422                let inner_offset;
5423                let mut inner_depth = depth.clone();
5424                if inlined {
5425                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5426                    inner_offset = next_offset;
5427                } else {
5428                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5429                    inner_depth.increment()?;
5430                }
5431                let val_ref =
5432                    self.scan_response.get_or_insert_with(|| fidl::new_empty!(AdvertisingData, D));
5433                fidl::decode!(AdvertisingData, D, val_ref, decoder, inner_offset, inner_depth)?;
5434                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5435                {
5436                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5437                }
5438                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5439                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5440                }
5441            }
5442
5443            next_offset += envelope_size;
5444            _next_ordinal_to_read += 1;
5445            if next_offset >= end_offset {
5446                return Ok(());
5447            }
5448
5449            // Decode unknown envelopes for gaps in ordinals.
5450            while _next_ordinal_to_read < 3 {
5451                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5452                _next_ordinal_to_read += 1;
5453                next_offset += envelope_size;
5454            }
5455
5456            let next_out_of_line = decoder.next_out_of_line();
5457            let handles_before = decoder.remaining_handles();
5458            if let Some((inlined, num_bytes, num_handles)) =
5459                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5460            {
5461                let member_inline_size =
5462                    <AdvertisingModeHint as fidl::encoding::TypeMarker>::inline_size(
5463                        decoder.context,
5464                    );
5465                if inlined != (member_inline_size <= 4) {
5466                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5467                }
5468                let inner_offset;
5469                let mut inner_depth = depth.clone();
5470                if inlined {
5471                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5472                    inner_offset = next_offset;
5473                } else {
5474                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5475                    inner_depth.increment()?;
5476                }
5477                let val_ref =
5478                    self.mode_hint.get_or_insert_with(|| fidl::new_empty!(AdvertisingModeHint, D));
5479                fidl::decode!(AdvertisingModeHint, D, val_ref, decoder, inner_offset, inner_depth)?;
5480                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5481                {
5482                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5483                }
5484                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5485                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5486                }
5487            }
5488
5489            next_offset += envelope_size;
5490            _next_ordinal_to_read += 1;
5491            if next_offset >= end_offset {
5492                return Ok(());
5493            }
5494
5495            // Decode unknown envelopes for gaps in ordinals.
5496            while _next_ordinal_to_read < 4 {
5497                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5498                _next_ordinal_to_read += 1;
5499                next_offset += envelope_size;
5500            }
5501
5502            let next_out_of_line = decoder.next_out_of_line();
5503            let handles_before = decoder.remaining_handles();
5504            if let Some((inlined, num_bytes, num_handles)) =
5505                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5506            {
5507                let member_inline_size =
5508                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5509                if inlined != (member_inline_size <= 4) {
5510                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5511                }
5512                let inner_offset;
5513                let mut inner_depth = depth.clone();
5514                if inlined {
5515                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5516                    inner_offset = next_offset;
5517                } else {
5518                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5519                    inner_depth.increment()?;
5520                }
5521                let val_ref = self.connectable.get_or_insert_with(|| fidl::new_empty!(bool, D));
5522                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5523                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5524                {
5525                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5526                }
5527                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5528                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5529                }
5530            }
5531
5532            next_offset += envelope_size;
5533            _next_ordinal_to_read += 1;
5534            if next_offset >= end_offset {
5535                return Ok(());
5536            }
5537
5538            // Decode unknown envelopes for gaps in ordinals.
5539            while _next_ordinal_to_read < 5 {
5540                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5541                _next_ordinal_to_read += 1;
5542                next_offset += envelope_size;
5543            }
5544
5545            let next_out_of_line = decoder.next_out_of_line();
5546            let handles_before = decoder.remaining_handles();
5547            if let Some((inlined, num_bytes, num_handles)) =
5548                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5549            {
5550                let member_inline_size =
5551                    <ConnectionOptions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5552                if inlined != (member_inline_size <= 4) {
5553                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5554                }
5555                let inner_offset;
5556                let mut inner_depth = depth.clone();
5557                if inlined {
5558                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5559                    inner_offset = next_offset;
5560                } else {
5561                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5562                    inner_depth.increment()?;
5563                }
5564                let val_ref = self
5565                    .connection_options
5566                    .get_or_insert_with(|| fidl::new_empty!(ConnectionOptions, D));
5567                fidl::decode!(ConnectionOptions, D, val_ref, decoder, inner_offset, inner_depth)?;
5568                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5569                {
5570                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5571                }
5572                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5573                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5574                }
5575            }
5576
5577            next_offset += envelope_size;
5578            _next_ordinal_to_read += 1;
5579            if next_offset >= end_offset {
5580                return Ok(());
5581            }
5582
5583            // Decode unknown envelopes for gaps in ordinals.
5584            while _next_ordinal_to_read < 6 {
5585                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5586                _next_ordinal_to_read += 1;
5587                next_offset += envelope_size;
5588            }
5589
5590            let next_out_of_line = decoder.next_out_of_line();
5591            let handles_before = decoder.remaining_handles();
5592            if let Some((inlined, num_bytes, num_handles)) =
5593                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5594            {
5595                let member_inline_size =
5596                    <AdvertisingProcedure as fidl::encoding::TypeMarker>::inline_size(
5597                        decoder.context,
5598                    );
5599                if inlined != (member_inline_size <= 4) {
5600                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5601                }
5602                let inner_offset;
5603                let mut inner_depth = depth.clone();
5604                if inlined {
5605                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5606                    inner_offset = next_offset;
5607                } else {
5608                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5609                    inner_depth.increment()?;
5610                }
5611                let val_ref = self
5612                    .advertising_procedure
5613                    .get_or_insert_with(|| fidl::new_empty!(AdvertisingProcedure, D));
5614                fidl::decode!(
5615                    AdvertisingProcedure,
5616                    D,
5617                    val_ref,
5618                    decoder,
5619                    inner_offset,
5620                    inner_depth
5621                )?;
5622                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5623                {
5624                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5625                }
5626                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5627                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5628                }
5629            }
5630
5631            next_offset += envelope_size;
5632            _next_ordinal_to_read += 1;
5633            if next_offset >= end_offset {
5634                return Ok(());
5635            }
5636
5637            // Decode unknown envelopes for gaps in ordinals.
5638            while _next_ordinal_to_read < 7 {
5639                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5640                _next_ordinal_to_read += 1;
5641                next_offset += envelope_size;
5642            }
5643
5644            let next_out_of_line = decoder.next_out_of_line();
5645            let handles_before = decoder.remaining_handles();
5646            if let Some((inlined, num_bytes, num_handles)) =
5647                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5648            {
5649                let member_inline_size = <fidl_fuchsia_bluetooth__common::AddressType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5650                if inlined != (member_inline_size <= 4) {
5651                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5652                }
5653                let inner_offset;
5654                let mut inner_depth = depth.clone();
5655                if inlined {
5656                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5657                    inner_offset = next_offset;
5658                } else {
5659                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5660                    inner_depth.increment()?;
5661                }
5662                let val_ref = self.address_type.get_or_insert_with(|| {
5663                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::AddressType, D)
5664                });
5665                fidl::decode!(
5666                    fidl_fuchsia_bluetooth__common::AddressType,
5667                    D,
5668                    val_ref,
5669                    decoder,
5670                    inner_offset,
5671                    inner_depth
5672                )?;
5673                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5674                {
5675                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5676                }
5677                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5678                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5679                }
5680            }
5681
5682            next_offset += envelope_size;
5683
5684            // Decode the remaining unknown envelopes.
5685            while next_offset < end_offset {
5686                _next_ordinal_to_read += 1;
5687                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5688                next_offset += envelope_size;
5689            }
5690
5691            Ok(())
5692        }
5693    }
5694
5695    impl CentralCreateConnectedIsochronousGroupResponse {
5696        #[inline(always)]
5697        fn max_ordinal_present(&self) -> u64 {
5698            if let Some(_) = self.cig_id {
5699                return 1;
5700            }
5701            0
5702        }
5703    }
5704
5705    impl fidl::encoding::ValueTypeMarker for CentralCreateConnectedIsochronousGroupResponse {
5706        type Borrowed<'a> = &'a Self;
5707        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5708            value
5709        }
5710    }
5711
5712    unsafe impl fidl::encoding::TypeMarker for CentralCreateConnectedIsochronousGroupResponse {
5713        type Owned = Self;
5714
5715        #[inline(always)]
5716        fn inline_align(_context: fidl::encoding::Context) -> usize {
5717            8
5718        }
5719
5720        #[inline(always)]
5721        fn inline_size(_context: fidl::encoding::Context) -> usize {
5722            16
5723        }
5724    }
5725
5726    unsafe impl<D: fidl::encoding::ResourceDialect>
5727        fidl::encoding::Encode<CentralCreateConnectedIsochronousGroupResponse, D>
5728        for &CentralCreateConnectedIsochronousGroupResponse
5729    {
5730        unsafe fn encode(
5731            self,
5732            encoder: &mut fidl::encoding::Encoder<'_, D>,
5733            offset: usize,
5734            mut depth: fidl::encoding::Depth,
5735        ) -> fidl::Result<()> {
5736            encoder.debug_check_bounds::<CentralCreateConnectedIsochronousGroupResponse>(offset);
5737            // Vector header
5738            let max_ordinal: u64 = self.max_ordinal_present();
5739            encoder.write_num(max_ordinal, offset);
5740            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5741            // Calling encoder.out_of_line_offset(0) is not allowed.
5742            if max_ordinal == 0 {
5743                return Ok(());
5744            }
5745            depth.increment()?;
5746            let envelope_size = 8;
5747            let bytes_len = max_ordinal as usize * envelope_size;
5748            #[allow(unused_variables)]
5749            let offset = encoder.out_of_line_offset(bytes_len);
5750            let mut _prev_end_offset: usize = 0;
5751            if 1 > max_ordinal {
5752                return Ok(());
5753            }
5754
5755            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5756            // are envelope_size bytes.
5757            let cur_offset: usize = (1 - 1) * envelope_size;
5758
5759            // Zero reserved fields.
5760            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5761
5762            // Safety:
5763            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5764            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5765            //   envelope_size bytes, there is always sufficient room.
5766            fidl::encoding::encode_in_envelope_optional::<u8, D>(
5767                self.cig_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
5768                encoder,
5769                offset + cur_offset,
5770                depth,
5771            )?;
5772
5773            _prev_end_offset = cur_offset + envelope_size;
5774
5775            Ok(())
5776        }
5777    }
5778
5779    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5780        for CentralCreateConnectedIsochronousGroupResponse
5781    {
5782        #[inline(always)]
5783        fn new_empty() -> Self {
5784            Self::default()
5785        }
5786
5787        unsafe fn decode(
5788            &mut self,
5789            decoder: &mut fidl::encoding::Decoder<'_, D>,
5790            offset: usize,
5791            mut depth: fidl::encoding::Depth,
5792        ) -> fidl::Result<()> {
5793            decoder.debug_check_bounds::<Self>(offset);
5794            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5795                None => return Err(fidl::Error::NotNullable),
5796                Some(len) => len,
5797            };
5798            // Calling decoder.out_of_line_offset(0) is not allowed.
5799            if len == 0 {
5800                return Ok(());
5801            };
5802            depth.increment()?;
5803            let envelope_size = 8;
5804            let bytes_len = len * envelope_size;
5805            let offset = decoder.out_of_line_offset(bytes_len)?;
5806            // Decode the envelope for each type.
5807            let mut _next_ordinal_to_read = 0;
5808            let mut next_offset = offset;
5809            let end_offset = offset + bytes_len;
5810            _next_ordinal_to_read += 1;
5811            if next_offset >= end_offset {
5812                return Ok(());
5813            }
5814
5815            // Decode unknown envelopes for gaps in ordinals.
5816            while _next_ordinal_to_read < 1 {
5817                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5818                _next_ordinal_to_read += 1;
5819                next_offset += envelope_size;
5820            }
5821
5822            let next_out_of_line = decoder.next_out_of_line();
5823            let handles_before = decoder.remaining_handles();
5824            if let Some((inlined, num_bytes, num_handles)) =
5825                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5826            {
5827                let member_inline_size =
5828                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5829                if inlined != (member_inline_size <= 4) {
5830                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5831                }
5832                let inner_offset;
5833                let mut inner_depth = depth.clone();
5834                if inlined {
5835                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5836                    inner_offset = next_offset;
5837                } else {
5838                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5839                    inner_depth.increment()?;
5840                }
5841                let val_ref = self.cig_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
5842                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
5843                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5844                {
5845                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5846                }
5847                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5848                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5849                }
5850            }
5851
5852            next_offset += envelope_size;
5853
5854            // Decode the remaining unknown envelopes.
5855            while next_offset < end_offset {
5856                _next_ordinal_to_read += 1;
5857                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5858                next_offset += envelope_size;
5859            }
5860
5861            Ok(())
5862        }
5863    }
5864
5865    impl ChannelListenerRegistryListenL2capResponse {
5866        #[inline(always)]
5867        fn max_ordinal_present(&self) -> u64 {
5868            if let Some(_) = self.psm {
5869                return 1;
5870            }
5871            0
5872        }
5873    }
5874
5875    impl fidl::encoding::ValueTypeMarker for ChannelListenerRegistryListenL2capResponse {
5876        type Borrowed<'a> = &'a Self;
5877        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5878            value
5879        }
5880    }
5881
5882    unsafe impl fidl::encoding::TypeMarker for ChannelListenerRegistryListenL2capResponse {
5883        type Owned = Self;
5884
5885        #[inline(always)]
5886        fn inline_align(_context: fidl::encoding::Context) -> usize {
5887            8
5888        }
5889
5890        #[inline(always)]
5891        fn inline_size(_context: fidl::encoding::Context) -> usize {
5892            16
5893        }
5894    }
5895
5896    unsafe impl<D: fidl::encoding::ResourceDialect>
5897        fidl::encoding::Encode<ChannelListenerRegistryListenL2capResponse, D>
5898        for &ChannelListenerRegistryListenL2capResponse
5899    {
5900        unsafe fn encode(
5901            self,
5902            encoder: &mut fidl::encoding::Encoder<'_, D>,
5903            offset: usize,
5904            mut depth: fidl::encoding::Depth,
5905        ) -> fidl::Result<()> {
5906            encoder.debug_check_bounds::<ChannelListenerRegistryListenL2capResponse>(offset);
5907            // Vector header
5908            let max_ordinal: u64 = self.max_ordinal_present();
5909            encoder.write_num(max_ordinal, offset);
5910            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5911            // Calling encoder.out_of_line_offset(0) is not allowed.
5912            if max_ordinal == 0 {
5913                return Ok(());
5914            }
5915            depth.increment()?;
5916            let envelope_size = 8;
5917            let bytes_len = max_ordinal as usize * envelope_size;
5918            #[allow(unused_variables)]
5919            let offset = encoder.out_of_line_offset(bytes_len);
5920            let mut _prev_end_offset: usize = 0;
5921            if 1 > max_ordinal {
5922                return Ok(());
5923            }
5924
5925            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5926            // are envelope_size bytes.
5927            let cur_offset: usize = (1 - 1) * envelope_size;
5928
5929            // Zero reserved fields.
5930            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5931
5932            // Safety:
5933            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5934            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5935            //   envelope_size bytes, there is always sufficient room.
5936            fidl::encoding::encode_in_envelope_optional::<u16, D>(
5937                self.psm.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5938                encoder,
5939                offset + cur_offset,
5940                depth,
5941            )?;
5942
5943            _prev_end_offset = cur_offset + envelope_size;
5944
5945            Ok(())
5946        }
5947    }
5948
5949    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5950        for ChannelListenerRegistryListenL2capResponse
5951    {
5952        #[inline(always)]
5953        fn new_empty() -> Self {
5954            Self::default()
5955        }
5956
5957        unsafe fn decode(
5958            &mut self,
5959            decoder: &mut fidl::encoding::Decoder<'_, D>,
5960            offset: usize,
5961            mut depth: fidl::encoding::Depth,
5962        ) -> fidl::Result<()> {
5963            decoder.debug_check_bounds::<Self>(offset);
5964            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5965                None => return Err(fidl::Error::NotNullable),
5966                Some(len) => len,
5967            };
5968            // Calling decoder.out_of_line_offset(0) is not allowed.
5969            if len == 0 {
5970                return Ok(());
5971            };
5972            depth.increment()?;
5973            let envelope_size = 8;
5974            let bytes_len = len * envelope_size;
5975            let offset = decoder.out_of_line_offset(bytes_len)?;
5976            // Decode the envelope for each type.
5977            let mut _next_ordinal_to_read = 0;
5978            let mut next_offset = offset;
5979            let end_offset = offset + bytes_len;
5980            _next_ordinal_to_read += 1;
5981            if next_offset >= end_offset {
5982                return Ok(());
5983            }
5984
5985            // Decode unknown envelopes for gaps in ordinals.
5986            while _next_ordinal_to_read < 1 {
5987                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5988                _next_ordinal_to_read += 1;
5989                next_offset += envelope_size;
5990            }
5991
5992            let next_out_of_line = decoder.next_out_of_line();
5993            let handles_before = decoder.remaining_handles();
5994            if let Some((inlined, num_bytes, num_handles)) =
5995                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5996            {
5997                let member_inline_size =
5998                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5999                if inlined != (member_inline_size <= 4) {
6000                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6001                }
6002                let inner_offset;
6003                let mut inner_depth = depth.clone();
6004                if inlined {
6005                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6006                    inner_offset = next_offset;
6007                } else {
6008                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6009                    inner_depth.increment()?;
6010                }
6011                let val_ref = self.psm.get_or_insert_with(|| fidl::new_empty!(u16, D));
6012                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6013                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6014                {
6015                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6016                }
6017                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6018                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6019                }
6020            }
6021
6022            next_offset += envelope_size;
6023
6024            // Decode the remaining unknown envelopes.
6025            while next_offset < end_offset {
6026                _next_ordinal_to_read += 1;
6027                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6028                next_offset += envelope_size;
6029            }
6030
6031            Ok(())
6032        }
6033    }
6034
6035    impl CigParameters {
6036        #[inline(always)]
6037        fn max_ordinal_present(&self) -> u64 {
6038            if let Some(_) = self.max_transport_latency_p_to_c {
6039                return 6;
6040            }
6041            if let Some(_) = self.max_transport_latency_c_to_p {
6042                return 5;
6043            }
6044            if let Some(_) = self.framing {
6045                return 4;
6046            }
6047            if let Some(_) = self.packing {
6048                return 3;
6049            }
6050            if let Some(_) = self.sdu_interval_p_to_c {
6051                return 2;
6052            }
6053            if let Some(_) = self.sdu_interval_c_to_p {
6054                return 1;
6055            }
6056            0
6057        }
6058    }
6059
6060    impl fidl::encoding::ValueTypeMarker for CigParameters {
6061        type Borrowed<'a> = &'a Self;
6062        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6063            value
6064        }
6065    }
6066
6067    unsafe impl fidl::encoding::TypeMarker for CigParameters {
6068        type Owned = Self;
6069
6070        #[inline(always)]
6071        fn inline_align(_context: fidl::encoding::Context) -> usize {
6072            8
6073        }
6074
6075        #[inline(always)]
6076        fn inline_size(_context: fidl::encoding::Context) -> usize {
6077            16
6078        }
6079    }
6080
6081    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CigParameters, D>
6082        for &CigParameters
6083    {
6084        unsafe fn encode(
6085            self,
6086            encoder: &mut fidl::encoding::Encoder<'_, D>,
6087            offset: usize,
6088            mut depth: fidl::encoding::Depth,
6089        ) -> fidl::Result<()> {
6090            encoder.debug_check_bounds::<CigParameters>(offset);
6091            // Vector header
6092            let max_ordinal: u64 = self.max_ordinal_present();
6093            encoder.write_num(max_ordinal, offset);
6094            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6095            // Calling encoder.out_of_line_offset(0) is not allowed.
6096            if max_ordinal == 0 {
6097                return Ok(());
6098            }
6099            depth.increment()?;
6100            let envelope_size = 8;
6101            let bytes_len = max_ordinal as usize * envelope_size;
6102            #[allow(unused_variables)]
6103            let offset = encoder.out_of_line_offset(bytes_len);
6104            let mut _prev_end_offset: usize = 0;
6105            if 1 > max_ordinal {
6106                return Ok(());
6107            }
6108
6109            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6110            // are envelope_size bytes.
6111            let cur_offset: usize = (1 - 1) * envelope_size;
6112
6113            // Zero reserved fields.
6114            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6115
6116            // Safety:
6117            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6118            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6119            //   envelope_size bytes, there is always sufficient room.
6120            fidl::encoding::encode_in_envelope_optional::<u32, D>(
6121                self.sdu_interval_c_to_p
6122                    .as_ref()
6123                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6124                encoder,
6125                offset + cur_offset,
6126                depth,
6127            )?;
6128
6129            _prev_end_offset = cur_offset + envelope_size;
6130            if 2 > max_ordinal {
6131                return Ok(());
6132            }
6133
6134            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6135            // are envelope_size bytes.
6136            let cur_offset: usize = (2 - 1) * envelope_size;
6137
6138            // Zero reserved fields.
6139            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6140
6141            // Safety:
6142            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6143            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6144            //   envelope_size bytes, there is always sufficient room.
6145            fidl::encoding::encode_in_envelope_optional::<u32, D>(
6146                self.sdu_interval_p_to_c
6147                    .as_ref()
6148                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6149                encoder,
6150                offset + cur_offset,
6151                depth,
6152            )?;
6153
6154            _prev_end_offset = cur_offset + envelope_size;
6155            if 3 > max_ordinal {
6156                return Ok(());
6157            }
6158
6159            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6160            // are envelope_size bytes.
6161            let cur_offset: usize = (3 - 1) * envelope_size;
6162
6163            // Zero reserved fields.
6164            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6165
6166            // Safety:
6167            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6168            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6169            //   envelope_size bytes, there is always sufficient room.
6170            fidl::encoding::encode_in_envelope_optional::<CigPacking, D>(
6171                self.packing.as_ref().map(<CigPacking as fidl::encoding::ValueTypeMarker>::borrow),
6172                encoder,
6173                offset + cur_offset,
6174                depth,
6175            )?;
6176
6177            _prev_end_offset = cur_offset + envelope_size;
6178            if 4 > max_ordinal {
6179                return Ok(());
6180            }
6181
6182            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6183            // are envelope_size bytes.
6184            let cur_offset: usize = (4 - 1) * envelope_size;
6185
6186            // Zero reserved fields.
6187            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6188
6189            // Safety:
6190            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6191            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6192            //   envelope_size bytes, there is always sufficient room.
6193            fidl::encoding::encode_in_envelope_optional::<CigFramingOptions, D>(
6194                self.framing
6195                    .as_ref()
6196                    .map(<CigFramingOptions as fidl::encoding::ValueTypeMarker>::borrow),
6197                encoder,
6198                offset + cur_offset,
6199                depth,
6200            )?;
6201
6202            _prev_end_offset = cur_offset + envelope_size;
6203            if 5 > max_ordinal {
6204                return Ok(());
6205            }
6206
6207            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6208            // are envelope_size bytes.
6209            let cur_offset: usize = (5 - 1) * envelope_size;
6210
6211            // Zero reserved fields.
6212            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6213
6214            // Safety:
6215            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6216            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6217            //   envelope_size bytes, there is always sufficient room.
6218            fidl::encoding::encode_in_envelope_optional::<u16, D>(
6219                self.max_transport_latency_c_to_p
6220                    .as_ref()
6221                    .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
6222                encoder,
6223                offset + cur_offset,
6224                depth,
6225            )?;
6226
6227            _prev_end_offset = cur_offset + envelope_size;
6228            if 6 > max_ordinal {
6229                return Ok(());
6230            }
6231
6232            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6233            // are envelope_size bytes.
6234            let cur_offset: usize = (6 - 1) * envelope_size;
6235
6236            // Zero reserved fields.
6237            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6238
6239            // Safety:
6240            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6241            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6242            //   envelope_size bytes, there is always sufficient room.
6243            fidl::encoding::encode_in_envelope_optional::<u16, D>(
6244                self.max_transport_latency_p_to_c
6245                    .as_ref()
6246                    .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
6247                encoder,
6248                offset + cur_offset,
6249                depth,
6250            )?;
6251
6252            _prev_end_offset = cur_offset + envelope_size;
6253
6254            Ok(())
6255        }
6256    }
6257
6258    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CigParameters {
6259        #[inline(always)]
6260        fn new_empty() -> Self {
6261            Self::default()
6262        }
6263
6264        unsafe fn decode(
6265            &mut self,
6266            decoder: &mut fidl::encoding::Decoder<'_, D>,
6267            offset: usize,
6268            mut depth: fidl::encoding::Depth,
6269        ) -> fidl::Result<()> {
6270            decoder.debug_check_bounds::<Self>(offset);
6271            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6272                None => return Err(fidl::Error::NotNullable),
6273                Some(len) => len,
6274            };
6275            // Calling decoder.out_of_line_offset(0) is not allowed.
6276            if len == 0 {
6277                return Ok(());
6278            };
6279            depth.increment()?;
6280            let envelope_size = 8;
6281            let bytes_len = len * envelope_size;
6282            let offset = decoder.out_of_line_offset(bytes_len)?;
6283            // Decode the envelope for each type.
6284            let mut _next_ordinal_to_read = 0;
6285            let mut next_offset = offset;
6286            let end_offset = offset + bytes_len;
6287            _next_ordinal_to_read += 1;
6288            if next_offset >= end_offset {
6289                return Ok(());
6290            }
6291
6292            // Decode unknown envelopes for gaps in ordinals.
6293            while _next_ordinal_to_read < 1 {
6294                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6295                _next_ordinal_to_read += 1;
6296                next_offset += envelope_size;
6297            }
6298
6299            let next_out_of_line = decoder.next_out_of_line();
6300            let handles_before = decoder.remaining_handles();
6301            if let Some((inlined, num_bytes, num_handles)) =
6302                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6303            {
6304                let member_inline_size =
6305                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6306                if inlined != (member_inline_size <= 4) {
6307                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6308                }
6309                let inner_offset;
6310                let mut inner_depth = depth.clone();
6311                if inlined {
6312                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6313                    inner_offset = next_offset;
6314                } else {
6315                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6316                    inner_depth.increment()?;
6317                }
6318                let val_ref =
6319                    self.sdu_interval_c_to_p.get_or_insert_with(|| fidl::new_empty!(u32, D));
6320                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6321                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6322                {
6323                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6324                }
6325                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6326                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6327                }
6328            }
6329
6330            next_offset += envelope_size;
6331            _next_ordinal_to_read += 1;
6332            if next_offset >= end_offset {
6333                return Ok(());
6334            }
6335
6336            // Decode unknown envelopes for gaps in ordinals.
6337            while _next_ordinal_to_read < 2 {
6338                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6339                _next_ordinal_to_read += 1;
6340                next_offset += envelope_size;
6341            }
6342
6343            let next_out_of_line = decoder.next_out_of_line();
6344            let handles_before = decoder.remaining_handles();
6345            if let Some((inlined, num_bytes, num_handles)) =
6346                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6347            {
6348                let member_inline_size =
6349                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6350                if inlined != (member_inline_size <= 4) {
6351                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6352                }
6353                let inner_offset;
6354                let mut inner_depth = depth.clone();
6355                if inlined {
6356                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6357                    inner_offset = next_offset;
6358                } else {
6359                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6360                    inner_depth.increment()?;
6361                }
6362                let val_ref =
6363                    self.sdu_interval_p_to_c.get_or_insert_with(|| fidl::new_empty!(u32, D));
6364                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6365                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6366                {
6367                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6368                }
6369                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6370                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6371                }
6372            }
6373
6374            next_offset += envelope_size;
6375            _next_ordinal_to_read += 1;
6376            if next_offset >= end_offset {
6377                return Ok(());
6378            }
6379
6380            // Decode unknown envelopes for gaps in ordinals.
6381            while _next_ordinal_to_read < 3 {
6382                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6383                _next_ordinal_to_read += 1;
6384                next_offset += envelope_size;
6385            }
6386
6387            let next_out_of_line = decoder.next_out_of_line();
6388            let handles_before = decoder.remaining_handles();
6389            if let Some((inlined, num_bytes, num_handles)) =
6390                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6391            {
6392                let member_inline_size =
6393                    <CigPacking as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6394                if inlined != (member_inline_size <= 4) {
6395                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6396                }
6397                let inner_offset;
6398                let mut inner_depth = depth.clone();
6399                if inlined {
6400                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6401                    inner_offset = next_offset;
6402                } else {
6403                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6404                    inner_depth.increment()?;
6405                }
6406                let val_ref = self.packing.get_or_insert_with(|| fidl::new_empty!(CigPacking, D));
6407                fidl::decode!(CigPacking, D, val_ref, decoder, inner_offset, inner_depth)?;
6408                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6409                {
6410                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6411                }
6412                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6413                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6414                }
6415            }
6416
6417            next_offset += envelope_size;
6418            _next_ordinal_to_read += 1;
6419            if next_offset >= end_offset {
6420                return Ok(());
6421            }
6422
6423            // Decode unknown envelopes for gaps in ordinals.
6424            while _next_ordinal_to_read < 4 {
6425                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6426                _next_ordinal_to_read += 1;
6427                next_offset += envelope_size;
6428            }
6429
6430            let next_out_of_line = decoder.next_out_of_line();
6431            let handles_before = decoder.remaining_handles();
6432            if let Some((inlined, num_bytes, num_handles)) =
6433                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6434            {
6435                let member_inline_size =
6436                    <CigFramingOptions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6437                if inlined != (member_inline_size <= 4) {
6438                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6439                }
6440                let inner_offset;
6441                let mut inner_depth = depth.clone();
6442                if inlined {
6443                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6444                    inner_offset = next_offset;
6445                } else {
6446                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6447                    inner_depth.increment()?;
6448                }
6449                let val_ref =
6450                    self.framing.get_or_insert_with(|| fidl::new_empty!(CigFramingOptions, D));
6451                fidl::decode!(CigFramingOptions, D, val_ref, decoder, inner_offset, inner_depth)?;
6452                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6453                {
6454                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6455                }
6456                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6457                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6458                }
6459            }
6460
6461            next_offset += envelope_size;
6462            _next_ordinal_to_read += 1;
6463            if next_offset >= end_offset {
6464                return Ok(());
6465            }
6466
6467            // Decode unknown envelopes for gaps in ordinals.
6468            while _next_ordinal_to_read < 5 {
6469                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6470                _next_ordinal_to_read += 1;
6471                next_offset += envelope_size;
6472            }
6473
6474            let next_out_of_line = decoder.next_out_of_line();
6475            let handles_before = decoder.remaining_handles();
6476            if let Some((inlined, num_bytes, num_handles)) =
6477                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6478            {
6479                let member_inline_size =
6480                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6481                if inlined != (member_inline_size <= 4) {
6482                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6483                }
6484                let inner_offset;
6485                let mut inner_depth = depth.clone();
6486                if inlined {
6487                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6488                    inner_offset = next_offset;
6489                } else {
6490                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6491                    inner_depth.increment()?;
6492                }
6493                let val_ref = self
6494                    .max_transport_latency_c_to_p
6495                    .get_or_insert_with(|| fidl::new_empty!(u16, D));
6496                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6497                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6498                {
6499                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6500                }
6501                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6502                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6503                }
6504            }
6505
6506            next_offset += envelope_size;
6507            _next_ordinal_to_read += 1;
6508            if next_offset >= end_offset {
6509                return Ok(());
6510            }
6511
6512            // Decode unknown envelopes for gaps in ordinals.
6513            while _next_ordinal_to_read < 6 {
6514                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6515                _next_ordinal_to_read += 1;
6516                next_offset += envelope_size;
6517            }
6518
6519            let next_out_of_line = decoder.next_out_of_line();
6520            let handles_before = decoder.remaining_handles();
6521            if let Some((inlined, num_bytes, num_handles)) =
6522                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6523            {
6524                let member_inline_size =
6525                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6526                if inlined != (member_inline_size <= 4) {
6527                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6528                }
6529                let inner_offset;
6530                let mut inner_depth = depth.clone();
6531                if inlined {
6532                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6533                    inner_offset = next_offset;
6534                } else {
6535                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6536                    inner_depth.increment()?;
6537                }
6538                let val_ref = self
6539                    .max_transport_latency_p_to_c
6540                    .get_or_insert_with(|| fidl::new_empty!(u16, D));
6541                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6542                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6543                {
6544                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6545                }
6546                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6547                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6548                }
6549            }
6550
6551            next_offset += envelope_size;
6552
6553            // Decode the remaining unknown envelopes.
6554            while next_offset < end_offset {
6555                _next_ordinal_to_read += 1;
6556                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6557                next_offset += envelope_size;
6558            }
6559
6560            Ok(())
6561        }
6562    }
6563
6564    impl CisEstablishedParameters {
6565        #[inline(always)]
6566        fn max_ordinal_present(&self) -> u64 {
6567            if let Some(_) = self.peripheral_to_central_params {
6568                return 6;
6569            }
6570            if let Some(_) = self.central_to_peripheral_params {
6571                return 5;
6572            }
6573            if let Some(_) = self.iso_interval {
6574                return 4;
6575            }
6576            if let Some(_) = self.max_subevents {
6577                return 3;
6578            }
6579            if let Some(_) = self.cis_sync_delay {
6580                return 2;
6581            }
6582            if let Some(_) = self.cig_sync_delay {
6583                return 1;
6584            }
6585            0
6586        }
6587    }
6588
6589    impl fidl::encoding::ValueTypeMarker for CisEstablishedParameters {
6590        type Borrowed<'a> = &'a Self;
6591        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6592            value
6593        }
6594    }
6595
6596    unsafe impl fidl::encoding::TypeMarker for CisEstablishedParameters {
6597        type Owned = Self;
6598
6599        #[inline(always)]
6600        fn inline_align(_context: fidl::encoding::Context) -> usize {
6601            8
6602        }
6603
6604        #[inline(always)]
6605        fn inline_size(_context: fidl::encoding::Context) -> usize {
6606            16
6607        }
6608    }
6609
6610    unsafe impl<D: fidl::encoding::ResourceDialect>
6611        fidl::encoding::Encode<CisEstablishedParameters, D> for &CisEstablishedParameters
6612    {
6613        unsafe fn encode(
6614            self,
6615            encoder: &mut fidl::encoding::Encoder<'_, D>,
6616            offset: usize,
6617            mut depth: fidl::encoding::Depth,
6618        ) -> fidl::Result<()> {
6619            encoder.debug_check_bounds::<CisEstablishedParameters>(offset);
6620            // Vector header
6621            let max_ordinal: u64 = self.max_ordinal_present();
6622            encoder.write_num(max_ordinal, offset);
6623            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6624            // Calling encoder.out_of_line_offset(0) is not allowed.
6625            if max_ordinal == 0 {
6626                return Ok(());
6627            }
6628            depth.increment()?;
6629            let envelope_size = 8;
6630            let bytes_len = max_ordinal as usize * envelope_size;
6631            #[allow(unused_variables)]
6632            let offset = encoder.out_of_line_offset(bytes_len);
6633            let mut _prev_end_offset: usize = 0;
6634            if 1 > max_ordinal {
6635                return Ok(());
6636            }
6637
6638            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6639            // are envelope_size bytes.
6640            let cur_offset: usize = (1 - 1) * envelope_size;
6641
6642            // Zero reserved fields.
6643            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6644
6645            // Safety:
6646            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6647            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6648            //   envelope_size bytes, there is always sufficient room.
6649            fidl::encoding::encode_in_envelope_optional::<i64, D>(
6650                self.cig_sync_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
6651                encoder,
6652                offset + cur_offset,
6653                depth,
6654            )?;
6655
6656            _prev_end_offset = cur_offset + envelope_size;
6657            if 2 > max_ordinal {
6658                return Ok(());
6659            }
6660
6661            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6662            // are envelope_size bytes.
6663            let cur_offset: usize = (2 - 1) * envelope_size;
6664
6665            // Zero reserved fields.
6666            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6667
6668            // Safety:
6669            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6670            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6671            //   envelope_size bytes, there is always sufficient room.
6672            fidl::encoding::encode_in_envelope_optional::<i64, D>(
6673                self.cis_sync_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
6674                encoder,
6675                offset + cur_offset,
6676                depth,
6677            )?;
6678
6679            _prev_end_offset = cur_offset + envelope_size;
6680            if 3 > max_ordinal {
6681                return Ok(());
6682            }
6683
6684            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6685            // are envelope_size bytes.
6686            let cur_offset: usize = (3 - 1) * envelope_size;
6687
6688            // Zero reserved fields.
6689            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6690
6691            // Safety:
6692            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6693            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6694            //   envelope_size bytes, there is always sufficient room.
6695            fidl::encoding::encode_in_envelope_optional::<u8, D>(
6696                self.max_subevents.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
6697                encoder,
6698                offset + cur_offset,
6699                depth,
6700            )?;
6701
6702            _prev_end_offset = cur_offset + envelope_size;
6703            if 4 > max_ordinal {
6704                return Ok(());
6705            }
6706
6707            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6708            // are envelope_size bytes.
6709            let cur_offset: usize = (4 - 1) * envelope_size;
6710
6711            // Zero reserved fields.
6712            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6713
6714            // Safety:
6715            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6716            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6717            //   envelope_size bytes, there is always sufficient room.
6718            fidl::encoding::encode_in_envelope_optional::<i64, D>(
6719                self.iso_interval.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
6720                encoder,
6721                offset + cur_offset,
6722                depth,
6723            )?;
6724
6725            _prev_end_offset = cur_offset + envelope_size;
6726            if 5 > max_ordinal {
6727                return Ok(());
6728            }
6729
6730            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6731            // are envelope_size bytes.
6732            let cur_offset: usize = (5 - 1) * envelope_size;
6733
6734            // Zero reserved fields.
6735            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6736
6737            // Safety:
6738            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6739            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6740            //   envelope_size bytes, there is always sufficient room.
6741            fidl::encoding::encode_in_envelope_optional::<CisUnidirectionalParams, D>(
6742                self.central_to_peripheral_params
6743                    .as_ref()
6744                    .map(<CisUnidirectionalParams as fidl::encoding::ValueTypeMarker>::borrow),
6745                encoder,
6746                offset + cur_offset,
6747                depth,
6748            )?;
6749
6750            _prev_end_offset = cur_offset + envelope_size;
6751            if 6 > max_ordinal {
6752                return Ok(());
6753            }
6754
6755            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6756            // are envelope_size bytes.
6757            let cur_offset: usize = (6 - 1) * envelope_size;
6758
6759            // Zero reserved fields.
6760            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6761
6762            // Safety:
6763            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6764            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6765            //   envelope_size bytes, there is always sufficient room.
6766            fidl::encoding::encode_in_envelope_optional::<CisUnidirectionalParams, D>(
6767                self.peripheral_to_central_params
6768                    .as_ref()
6769                    .map(<CisUnidirectionalParams as fidl::encoding::ValueTypeMarker>::borrow),
6770                encoder,
6771                offset + cur_offset,
6772                depth,
6773            )?;
6774
6775            _prev_end_offset = cur_offset + envelope_size;
6776
6777            Ok(())
6778        }
6779    }
6780
6781    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6782        for CisEstablishedParameters
6783    {
6784        #[inline(always)]
6785        fn new_empty() -> Self {
6786            Self::default()
6787        }
6788
6789        unsafe fn decode(
6790            &mut self,
6791            decoder: &mut fidl::encoding::Decoder<'_, D>,
6792            offset: usize,
6793            mut depth: fidl::encoding::Depth,
6794        ) -> fidl::Result<()> {
6795            decoder.debug_check_bounds::<Self>(offset);
6796            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6797                None => return Err(fidl::Error::NotNullable),
6798                Some(len) => len,
6799            };
6800            // Calling decoder.out_of_line_offset(0) is not allowed.
6801            if len == 0 {
6802                return Ok(());
6803            };
6804            depth.increment()?;
6805            let envelope_size = 8;
6806            let bytes_len = len * envelope_size;
6807            let offset = decoder.out_of_line_offset(bytes_len)?;
6808            // Decode the envelope for each type.
6809            let mut _next_ordinal_to_read = 0;
6810            let mut next_offset = offset;
6811            let end_offset = offset + bytes_len;
6812            _next_ordinal_to_read += 1;
6813            if next_offset >= end_offset {
6814                return Ok(());
6815            }
6816
6817            // Decode unknown envelopes for gaps in ordinals.
6818            while _next_ordinal_to_read < 1 {
6819                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6820                _next_ordinal_to_read += 1;
6821                next_offset += envelope_size;
6822            }
6823
6824            let next_out_of_line = decoder.next_out_of_line();
6825            let handles_before = decoder.remaining_handles();
6826            if let Some((inlined, num_bytes, num_handles)) =
6827                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6828            {
6829                let member_inline_size =
6830                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6831                if inlined != (member_inline_size <= 4) {
6832                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6833                }
6834                let inner_offset;
6835                let mut inner_depth = depth.clone();
6836                if inlined {
6837                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6838                    inner_offset = next_offset;
6839                } else {
6840                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6841                    inner_depth.increment()?;
6842                }
6843                let val_ref = self.cig_sync_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
6844                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6845                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6846                {
6847                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6848                }
6849                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6850                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6851                }
6852            }
6853
6854            next_offset += envelope_size;
6855            _next_ordinal_to_read += 1;
6856            if next_offset >= end_offset {
6857                return Ok(());
6858            }
6859
6860            // Decode unknown envelopes for gaps in ordinals.
6861            while _next_ordinal_to_read < 2 {
6862                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6863                _next_ordinal_to_read += 1;
6864                next_offset += envelope_size;
6865            }
6866
6867            let next_out_of_line = decoder.next_out_of_line();
6868            let handles_before = decoder.remaining_handles();
6869            if let Some((inlined, num_bytes, num_handles)) =
6870                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6871            {
6872                let member_inline_size =
6873                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6874                if inlined != (member_inline_size <= 4) {
6875                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6876                }
6877                let inner_offset;
6878                let mut inner_depth = depth.clone();
6879                if inlined {
6880                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6881                    inner_offset = next_offset;
6882                } else {
6883                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6884                    inner_depth.increment()?;
6885                }
6886                let val_ref = self.cis_sync_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
6887                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6888                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6889                {
6890                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6891                }
6892                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6893                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6894                }
6895            }
6896
6897            next_offset += envelope_size;
6898            _next_ordinal_to_read += 1;
6899            if next_offset >= end_offset {
6900                return Ok(());
6901            }
6902
6903            // Decode unknown envelopes for gaps in ordinals.
6904            while _next_ordinal_to_read < 3 {
6905                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6906                _next_ordinal_to_read += 1;
6907                next_offset += envelope_size;
6908            }
6909
6910            let next_out_of_line = decoder.next_out_of_line();
6911            let handles_before = decoder.remaining_handles();
6912            if let Some((inlined, num_bytes, num_handles)) =
6913                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6914            {
6915                let member_inline_size =
6916                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6917                if inlined != (member_inline_size <= 4) {
6918                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6919                }
6920                let inner_offset;
6921                let mut inner_depth = depth.clone();
6922                if inlined {
6923                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6924                    inner_offset = next_offset;
6925                } else {
6926                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6927                    inner_depth.increment()?;
6928                }
6929                let val_ref = self.max_subevents.get_or_insert_with(|| fidl::new_empty!(u8, D));
6930                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
6931                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6932                {
6933                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6934                }
6935                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6936                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6937                }
6938            }
6939
6940            next_offset += envelope_size;
6941            _next_ordinal_to_read += 1;
6942            if next_offset >= end_offset {
6943                return Ok(());
6944            }
6945
6946            // Decode unknown envelopes for gaps in ordinals.
6947            while _next_ordinal_to_read < 4 {
6948                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6949                _next_ordinal_to_read += 1;
6950                next_offset += envelope_size;
6951            }
6952
6953            let next_out_of_line = decoder.next_out_of_line();
6954            let handles_before = decoder.remaining_handles();
6955            if let Some((inlined, num_bytes, num_handles)) =
6956                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6957            {
6958                let member_inline_size =
6959                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6960                if inlined != (member_inline_size <= 4) {
6961                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6962                }
6963                let inner_offset;
6964                let mut inner_depth = depth.clone();
6965                if inlined {
6966                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6967                    inner_offset = next_offset;
6968                } else {
6969                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6970                    inner_depth.increment()?;
6971                }
6972                let val_ref = self.iso_interval.get_or_insert_with(|| fidl::new_empty!(i64, D));
6973                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6974                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6975                {
6976                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6977                }
6978                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6979                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6980                }
6981            }
6982
6983            next_offset += envelope_size;
6984            _next_ordinal_to_read += 1;
6985            if next_offset >= end_offset {
6986                return Ok(());
6987            }
6988
6989            // Decode unknown envelopes for gaps in ordinals.
6990            while _next_ordinal_to_read < 5 {
6991                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6992                _next_ordinal_to_read += 1;
6993                next_offset += envelope_size;
6994            }
6995
6996            let next_out_of_line = decoder.next_out_of_line();
6997            let handles_before = decoder.remaining_handles();
6998            if let Some((inlined, num_bytes, num_handles)) =
6999                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7000            {
7001                let member_inline_size =
7002                    <CisUnidirectionalParams as fidl::encoding::TypeMarker>::inline_size(
7003                        decoder.context,
7004                    );
7005                if inlined != (member_inline_size <= 4) {
7006                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7007                }
7008                let inner_offset;
7009                let mut inner_depth = depth.clone();
7010                if inlined {
7011                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7012                    inner_offset = next_offset;
7013                } else {
7014                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7015                    inner_depth.increment()?;
7016                }
7017                let val_ref = self
7018                    .central_to_peripheral_params
7019                    .get_or_insert_with(|| fidl::new_empty!(CisUnidirectionalParams, D));
7020                fidl::decode!(
7021                    CisUnidirectionalParams,
7022                    D,
7023                    val_ref,
7024                    decoder,
7025                    inner_offset,
7026                    inner_depth
7027                )?;
7028                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7029                {
7030                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7031                }
7032                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7033                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7034                }
7035            }
7036
7037            next_offset += envelope_size;
7038            _next_ordinal_to_read += 1;
7039            if next_offset >= end_offset {
7040                return Ok(());
7041            }
7042
7043            // Decode unknown envelopes for gaps in ordinals.
7044            while _next_ordinal_to_read < 6 {
7045                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7046                _next_ordinal_to_read += 1;
7047                next_offset += envelope_size;
7048            }
7049
7050            let next_out_of_line = decoder.next_out_of_line();
7051            let handles_before = decoder.remaining_handles();
7052            if let Some((inlined, num_bytes, num_handles)) =
7053                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7054            {
7055                let member_inline_size =
7056                    <CisUnidirectionalParams as fidl::encoding::TypeMarker>::inline_size(
7057                        decoder.context,
7058                    );
7059                if inlined != (member_inline_size <= 4) {
7060                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7061                }
7062                let inner_offset;
7063                let mut inner_depth = depth.clone();
7064                if inlined {
7065                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7066                    inner_offset = next_offset;
7067                } else {
7068                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7069                    inner_depth.increment()?;
7070                }
7071                let val_ref = self
7072                    .peripheral_to_central_params
7073                    .get_or_insert_with(|| fidl::new_empty!(CisUnidirectionalParams, D));
7074                fidl::decode!(
7075                    CisUnidirectionalParams,
7076                    D,
7077                    val_ref,
7078                    decoder,
7079                    inner_offset,
7080                    inner_depth
7081                )?;
7082                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7083                {
7084                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7085                }
7086                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7087                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7088                }
7089            }
7090
7091            next_offset += envelope_size;
7092
7093            // Decode the remaining unknown envelopes.
7094            while next_offset < end_offset {
7095                _next_ordinal_to_read += 1;
7096                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7097                next_offset += envelope_size;
7098            }
7099
7100            Ok(())
7101        }
7102    }
7103
7104    impl CisParameters {
7105        #[inline(always)]
7106        fn max_ordinal_present(&self) -> u64 {
7107            if let Some(_) = self.id {
7108                return 2;
7109            }
7110            if let Some(_) = self.cis_id {
7111                return 1;
7112            }
7113            0
7114        }
7115    }
7116
7117    impl fidl::encoding::ValueTypeMarker for CisParameters {
7118        type Borrowed<'a> = &'a Self;
7119        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7120            value
7121        }
7122    }
7123
7124    unsafe impl fidl::encoding::TypeMarker for CisParameters {
7125        type Owned = Self;
7126
7127        #[inline(always)]
7128        fn inline_align(_context: fidl::encoding::Context) -> usize {
7129            8
7130        }
7131
7132        #[inline(always)]
7133        fn inline_size(_context: fidl::encoding::Context) -> usize {
7134            16
7135        }
7136    }
7137
7138    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CisParameters, D>
7139        for &CisParameters
7140    {
7141        unsafe fn encode(
7142            self,
7143            encoder: &mut fidl::encoding::Encoder<'_, D>,
7144            offset: usize,
7145            mut depth: fidl::encoding::Depth,
7146        ) -> fidl::Result<()> {
7147            encoder.debug_check_bounds::<CisParameters>(offset);
7148            // Vector header
7149            let max_ordinal: u64 = self.max_ordinal_present();
7150            encoder.write_num(max_ordinal, offset);
7151            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7152            // Calling encoder.out_of_line_offset(0) is not allowed.
7153            if max_ordinal == 0 {
7154                return Ok(());
7155            }
7156            depth.increment()?;
7157            let envelope_size = 8;
7158            let bytes_len = max_ordinal as usize * envelope_size;
7159            #[allow(unused_variables)]
7160            let offset = encoder.out_of_line_offset(bytes_len);
7161            let mut _prev_end_offset: usize = 0;
7162            if 1 > max_ordinal {
7163                return Ok(());
7164            }
7165
7166            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7167            // are envelope_size bytes.
7168            let cur_offset: usize = (1 - 1) * envelope_size;
7169
7170            // Zero reserved fields.
7171            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7172
7173            // Safety:
7174            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7175            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7176            //   envelope_size bytes, there is always sufficient room.
7177            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7178                self.cis_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7179                encoder,
7180                offset + cur_offset,
7181                depth,
7182            )?;
7183
7184            _prev_end_offset = cur_offset + envelope_size;
7185            if 2 > max_ordinal {
7186                return Ok(());
7187            }
7188
7189            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7190            // are envelope_size bytes.
7191            let cur_offset: usize = (2 - 1) * envelope_size;
7192
7193            // Zero reserved fields.
7194            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7195
7196            // Safety:
7197            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7198            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7199            //   envelope_size bytes, there is always sufficient room.
7200            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::PeerId, D>(
7201            self.id.as_ref().map(<fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow),
7202            encoder, offset + cur_offset, depth
7203        )?;
7204
7205            _prev_end_offset = cur_offset + envelope_size;
7206
7207            Ok(())
7208        }
7209    }
7210
7211    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CisParameters {
7212        #[inline(always)]
7213        fn new_empty() -> Self {
7214            Self::default()
7215        }
7216
7217        unsafe fn decode(
7218            &mut self,
7219            decoder: &mut fidl::encoding::Decoder<'_, D>,
7220            offset: usize,
7221            mut depth: fidl::encoding::Depth,
7222        ) -> fidl::Result<()> {
7223            decoder.debug_check_bounds::<Self>(offset);
7224            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7225                None => return Err(fidl::Error::NotNullable),
7226                Some(len) => len,
7227            };
7228            // Calling decoder.out_of_line_offset(0) is not allowed.
7229            if len == 0 {
7230                return Ok(());
7231            };
7232            depth.increment()?;
7233            let envelope_size = 8;
7234            let bytes_len = len * envelope_size;
7235            let offset = decoder.out_of_line_offset(bytes_len)?;
7236            // Decode the envelope for each type.
7237            let mut _next_ordinal_to_read = 0;
7238            let mut next_offset = offset;
7239            let end_offset = offset + bytes_len;
7240            _next_ordinal_to_read += 1;
7241            if next_offset >= end_offset {
7242                return Ok(());
7243            }
7244
7245            // Decode unknown envelopes for gaps in ordinals.
7246            while _next_ordinal_to_read < 1 {
7247                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7248                _next_ordinal_to_read += 1;
7249                next_offset += envelope_size;
7250            }
7251
7252            let next_out_of_line = decoder.next_out_of_line();
7253            let handles_before = decoder.remaining_handles();
7254            if let Some((inlined, num_bytes, num_handles)) =
7255                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7256            {
7257                let member_inline_size =
7258                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7259                if inlined != (member_inline_size <= 4) {
7260                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7261                }
7262                let inner_offset;
7263                let mut inner_depth = depth.clone();
7264                if inlined {
7265                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7266                    inner_offset = next_offset;
7267                } else {
7268                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7269                    inner_depth.increment()?;
7270                }
7271                let val_ref = self.cis_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
7272                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7273                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7274                {
7275                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7276                }
7277                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7278                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7279                }
7280            }
7281
7282            next_offset += envelope_size;
7283            _next_ordinal_to_read += 1;
7284            if next_offset >= end_offset {
7285                return Ok(());
7286            }
7287
7288            // Decode unknown envelopes for gaps in ordinals.
7289            while _next_ordinal_to_read < 2 {
7290                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7291                _next_ordinal_to_read += 1;
7292                next_offset += envelope_size;
7293            }
7294
7295            let next_out_of_line = decoder.next_out_of_line();
7296            let handles_before = decoder.remaining_handles();
7297            if let Some((inlined, num_bytes, num_handles)) =
7298                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7299            {
7300                let member_inline_size = <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7301                if inlined != (member_inline_size <= 4) {
7302                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7303                }
7304                let inner_offset;
7305                let mut inner_depth = depth.clone();
7306                if inlined {
7307                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7308                    inner_offset = next_offset;
7309                } else {
7310                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7311                    inner_depth.increment()?;
7312                }
7313                let val_ref = self.id.get_or_insert_with(|| {
7314                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D)
7315                });
7316                fidl::decode!(
7317                    fidl_fuchsia_bluetooth__common::PeerId,
7318                    D,
7319                    val_ref,
7320                    decoder,
7321                    inner_offset,
7322                    inner_depth
7323                )?;
7324                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7325                {
7326                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7327                }
7328                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7329                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7330                }
7331            }
7332
7333            next_offset += envelope_size;
7334
7335            // Decode the remaining unknown envelopes.
7336            while next_offset < end_offset {
7337                _next_ordinal_to_read += 1;
7338                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7339                next_offset += envelope_size;
7340            }
7341
7342            Ok(())
7343        }
7344    }
7345
7346    impl CisUnidirectionalParams {
7347        #[inline(always)]
7348        fn max_ordinal_present(&self) -> u64 {
7349            if let Some(_) = self.flush_timeout {
7350                return 3;
7351            }
7352            if let Some(_) = self.burst_number {
7353                return 2;
7354            }
7355            if let Some(_) = self.transport_latency {
7356                return 1;
7357            }
7358            0
7359        }
7360    }
7361
7362    impl fidl::encoding::ValueTypeMarker for CisUnidirectionalParams {
7363        type Borrowed<'a> = &'a Self;
7364        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7365            value
7366        }
7367    }
7368
7369    unsafe impl fidl::encoding::TypeMarker for CisUnidirectionalParams {
7370        type Owned = Self;
7371
7372        #[inline(always)]
7373        fn inline_align(_context: fidl::encoding::Context) -> usize {
7374            8
7375        }
7376
7377        #[inline(always)]
7378        fn inline_size(_context: fidl::encoding::Context) -> usize {
7379            16
7380        }
7381    }
7382
7383    unsafe impl<D: fidl::encoding::ResourceDialect>
7384        fidl::encoding::Encode<CisUnidirectionalParams, D> for &CisUnidirectionalParams
7385    {
7386        unsafe fn encode(
7387            self,
7388            encoder: &mut fidl::encoding::Encoder<'_, D>,
7389            offset: usize,
7390            mut depth: fidl::encoding::Depth,
7391        ) -> fidl::Result<()> {
7392            encoder.debug_check_bounds::<CisUnidirectionalParams>(offset);
7393            // Vector header
7394            let max_ordinal: u64 = self.max_ordinal_present();
7395            encoder.write_num(max_ordinal, offset);
7396            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7397            // Calling encoder.out_of_line_offset(0) is not allowed.
7398            if max_ordinal == 0 {
7399                return Ok(());
7400            }
7401            depth.increment()?;
7402            let envelope_size = 8;
7403            let bytes_len = max_ordinal as usize * envelope_size;
7404            #[allow(unused_variables)]
7405            let offset = encoder.out_of_line_offset(bytes_len);
7406            let mut _prev_end_offset: usize = 0;
7407            if 1 > max_ordinal {
7408                return Ok(());
7409            }
7410
7411            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7412            // are envelope_size bytes.
7413            let cur_offset: usize = (1 - 1) * envelope_size;
7414
7415            // Zero reserved fields.
7416            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7417
7418            // Safety:
7419            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7420            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7421            //   envelope_size bytes, there is always sufficient room.
7422            fidl::encoding::encode_in_envelope_optional::<i64, D>(
7423                self.transport_latency
7424                    .as_ref()
7425                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
7426                encoder,
7427                offset + cur_offset,
7428                depth,
7429            )?;
7430
7431            _prev_end_offset = cur_offset + envelope_size;
7432            if 2 > max_ordinal {
7433                return Ok(());
7434            }
7435
7436            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7437            // are envelope_size bytes.
7438            let cur_offset: usize = (2 - 1) * envelope_size;
7439
7440            // Zero reserved fields.
7441            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7442
7443            // Safety:
7444            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7445            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7446            //   envelope_size bytes, there is always sufficient room.
7447            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7448                self.burst_number.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7449                encoder,
7450                offset + cur_offset,
7451                depth,
7452            )?;
7453
7454            _prev_end_offset = cur_offset + envelope_size;
7455            if 3 > max_ordinal {
7456                return Ok(());
7457            }
7458
7459            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7460            // are envelope_size bytes.
7461            let cur_offset: usize = (3 - 1) * envelope_size;
7462
7463            // Zero reserved fields.
7464            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7465
7466            // Safety:
7467            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7468            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7469            //   envelope_size bytes, there is always sufficient room.
7470            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7471                self.flush_timeout.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7472                encoder,
7473                offset + cur_offset,
7474                depth,
7475            )?;
7476
7477            _prev_end_offset = cur_offset + envelope_size;
7478
7479            Ok(())
7480        }
7481    }
7482
7483    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7484        for CisUnidirectionalParams
7485    {
7486        #[inline(always)]
7487        fn new_empty() -> Self {
7488            Self::default()
7489        }
7490
7491        unsafe fn decode(
7492            &mut self,
7493            decoder: &mut fidl::encoding::Decoder<'_, D>,
7494            offset: usize,
7495            mut depth: fidl::encoding::Depth,
7496        ) -> fidl::Result<()> {
7497            decoder.debug_check_bounds::<Self>(offset);
7498            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7499                None => return Err(fidl::Error::NotNullable),
7500                Some(len) => len,
7501            };
7502            // Calling decoder.out_of_line_offset(0) is not allowed.
7503            if len == 0 {
7504                return Ok(());
7505            };
7506            depth.increment()?;
7507            let envelope_size = 8;
7508            let bytes_len = len * envelope_size;
7509            let offset = decoder.out_of_line_offset(bytes_len)?;
7510            // Decode the envelope for each type.
7511            let mut _next_ordinal_to_read = 0;
7512            let mut next_offset = offset;
7513            let end_offset = offset + bytes_len;
7514            _next_ordinal_to_read += 1;
7515            if next_offset >= end_offset {
7516                return Ok(());
7517            }
7518
7519            // Decode unknown envelopes for gaps in ordinals.
7520            while _next_ordinal_to_read < 1 {
7521                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7522                _next_ordinal_to_read += 1;
7523                next_offset += envelope_size;
7524            }
7525
7526            let next_out_of_line = decoder.next_out_of_line();
7527            let handles_before = decoder.remaining_handles();
7528            if let Some((inlined, num_bytes, num_handles)) =
7529                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7530            {
7531                let member_inline_size =
7532                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7533                if inlined != (member_inline_size <= 4) {
7534                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7535                }
7536                let inner_offset;
7537                let mut inner_depth = depth.clone();
7538                if inlined {
7539                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7540                    inner_offset = next_offset;
7541                } else {
7542                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7543                    inner_depth.increment()?;
7544                }
7545                let val_ref =
7546                    self.transport_latency.get_or_insert_with(|| fidl::new_empty!(i64, D));
7547                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
7548                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7549                {
7550                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7551                }
7552                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7553                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7554                }
7555            }
7556
7557            next_offset += envelope_size;
7558            _next_ordinal_to_read += 1;
7559            if next_offset >= end_offset {
7560                return Ok(());
7561            }
7562
7563            // Decode unknown envelopes for gaps in ordinals.
7564            while _next_ordinal_to_read < 2 {
7565                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7566                _next_ordinal_to_read += 1;
7567                next_offset += envelope_size;
7568            }
7569
7570            let next_out_of_line = decoder.next_out_of_line();
7571            let handles_before = decoder.remaining_handles();
7572            if let Some((inlined, num_bytes, num_handles)) =
7573                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7574            {
7575                let member_inline_size =
7576                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7577                if inlined != (member_inline_size <= 4) {
7578                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7579                }
7580                let inner_offset;
7581                let mut inner_depth = depth.clone();
7582                if inlined {
7583                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7584                    inner_offset = next_offset;
7585                } else {
7586                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7587                    inner_depth.increment()?;
7588                }
7589                let val_ref = self.burst_number.get_or_insert_with(|| fidl::new_empty!(u8, D));
7590                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7591                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7592                {
7593                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7594                }
7595                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7596                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7597                }
7598            }
7599
7600            next_offset += envelope_size;
7601            _next_ordinal_to_read += 1;
7602            if next_offset >= end_offset {
7603                return Ok(());
7604            }
7605
7606            // Decode unknown envelopes for gaps in ordinals.
7607            while _next_ordinal_to_read < 3 {
7608                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7609                _next_ordinal_to_read += 1;
7610                next_offset += envelope_size;
7611            }
7612
7613            let next_out_of_line = decoder.next_out_of_line();
7614            let handles_before = decoder.remaining_handles();
7615            if let Some((inlined, num_bytes, num_handles)) =
7616                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7617            {
7618                let member_inline_size =
7619                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7620                if inlined != (member_inline_size <= 4) {
7621                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7622                }
7623                let inner_offset;
7624                let mut inner_depth = depth.clone();
7625                if inlined {
7626                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7627                    inner_offset = next_offset;
7628                } else {
7629                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7630                    inner_depth.increment()?;
7631                }
7632                let val_ref = self.flush_timeout.get_or_insert_with(|| fidl::new_empty!(u8, D));
7633                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7634                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7635                {
7636                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7637                }
7638                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7639                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7640                }
7641            }
7642
7643            next_offset += envelope_size;
7644
7645            // Decode the remaining unknown envelopes.
7646            while next_offset < end_offset {
7647                _next_ordinal_to_read += 1;
7648                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7649                next_offset += envelope_size;
7650            }
7651
7652            Ok(())
7653        }
7654    }
7655
7656    impl CodecDelayGetCodecLocalDelayRangeRequest {
7657        #[inline(always)]
7658        fn max_ordinal_present(&self) -> u64 {
7659            if let Some(_) = self.codec_attributes {
7660                return 3;
7661            }
7662            if let Some(_) = self.data_direction {
7663                return 2;
7664            }
7665            if let Some(_) = self.logical_transport_type {
7666                return 1;
7667            }
7668            0
7669        }
7670    }
7671
7672    impl fidl::encoding::ValueTypeMarker for CodecDelayGetCodecLocalDelayRangeRequest {
7673        type Borrowed<'a> = &'a Self;
7674        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7675            value
7676        }
7677    }
7678
7679    unsafe impl fidl::encoding::TypeMarker for CodecDelayGetCodecLocalDelayRangeRequest {
7680        type Owned = Self;
7681
7682        #[inline(always)]
7683        fn inline_align(_context: fidl::encoding::Context) -> usize {
7684            8
7685        }
7686
7687        #[inline(always)]
7688        fn inline_size(_context: fidl::encoding::Context) -> usize {
7689            16
7690        }
7691    }
7692
7693    unsafe impl<D: fidl::encoding::ResourceDialect>
7694        fidl::encoding::Encode<CodecDelayGetCodecLocalDelayRangeRequest, D>
7695        for &CodecDelayGetCodecLocalDelayRangeRequest
7696    {
7697        unsafe fn encode(
7698            self,
7699            encoder: &mut fidl::encoding::Encoder<'_, D>,
7700            offset: usize,
7701            mut depth: fidl::encoding::Depth,
7702        ) -> fidl::Result<()> {
7703            encoder.debug_check_bounds::<CodecDelayGetCodecLocalDelayRangeRequest>(offset);
7704            // Vector header
7705            let max_ordinal: u64 = self.max_ordinal_present();
7706            encoder.write_num(max_ordinal, offset);
7707            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7708            // Calling encoder.out_of_line_offset(0) is not allowed.
7709            if max_ordinal == 0 {
7710                return Ok(());
7711            }
7712            depth.increment()?;
7713            let envelope_size = 8;
7714            let bytes_len = max_ordinal as usize * envelope_size;
7715            #[allow(unused_variables)]
7716            let offset = encoder.out_of_line_offset(bytes_len);
7717            let mut _prev_end_offset: usize = 0;
7718            if 1 > max_ordinal {
7719                return Ok(());
7720            }
7721
7722            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7723            // are envelope_size bytes.
7724            let cur_offset: usize = (1 - 1) * envelope_size;
7725
7726            // Zero reserved fields.
7727            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7728
7729            // Safety:
7730            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7731            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7732            //   envelope_size bytes, there is always sufficient room.
7733            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::LogicalTransportType, D>(
7734            self.logical_transport_type.as_ref().map(<fidl_fuchsia_bluetooth__common::LogicalTransportType as fidl::encoding::ValueTypeMarker>::borrow),
7735            encoder, offset + cur_offset, depth
7736        )?;
7737
7738            _prev_end_offset = cur_offset + envelope_size;
7739            if 2 > max_ordinal {
7740                return Ok(());
7741            }
7742
7743            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7744            // are envelope_size bytes.
7745            let cur_offset: usize = (2 - 1) * envelope_size;
7746
7747            // Zero reserved fields.
7748            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7749
7750            // Safety:
7751            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7752            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7753            //   envelope_size bytes, there is always sufficient room.
7754            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::DataDirection, D>(
7755            self.data_direction.as_ref().map(<fidl_fuchsia_bluetooth__common::DataDirection as fidl::encoding::ValueTypeMarker>::borrow),
7756            encoder, offset + cur_offset, depth
7757        )?;
7758
7759            _prev_end_offset = cur_offset + envelope_size;
7760            if 3 > max_ordinal {
7761                return Ok(());
7762            }
7763
7764            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7765            // are envelope_size bytes.
7766            let cur_offset: usize = (3 - 1) * envelope_size;
7767
7768            // Zero reserved fields.
7769            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7770
7771            // Safety:
7772            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7773            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7774            //   envelope_size bytes, there is always sufficient room.
7775            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::CodecAttributes, D>(
7776            self.codec_attributes.as_ref().map(<fidl_fuchsia_bluetooth__common::CodecAttributes as fidl::encoding::ValueTypeMarker>::borrow),
7777            encoder, offset + cur_offset, depth
7778        )?;
7779
7780            _prev_end_offset = cur_offset + envelope_size;
7781
7782            Ok(())
7783        }
7784    }
7785
7786    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7787        for CodecDelayGetCodecLocalDelayRangeRequest
7788    {
7789        #[inline(always)]
7790        fn new_empty() -> Self {
7791            Self::default()
7792        }
7793
7794        unsafe fn decode(
7795            &mut self,
7796            decoder: &mut fidl::encoding::Decoder<'_, D>,
7797            offset: usize,
7798            mut depth: fidl::encoding::Depth,
7799        ) -> fidl::Result<()> {
7800            decoder.debug_check_bounds::<Self>(offset);
7801            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7802                None => return Err(fidl::Error::NotNullable),
7803                Some(len) => len,
7804            };
7805            // Calling decoder.out_of_line_offset(0) is not allowed.
7806            if len == 0 {
7807                return Ok(());
7808            };
7809            depth.increment()?;
7810            let envelope_size = 8;
7811            let bytes_len = len * envelope_size;
7812            let offset = decoder.out_of_line_offset(bytes_len)?;
7813            // Decode the envelope for each type.
7814            let mut _next_ordinal_to_read = 0;
7815            let mut next_offset = offset;
7816            let end_offset = offset + bytes_len;
7817            _next_ordinal_to_read += 1;
7818            if next_offset >= end_offset {
7819                return Ok(());
7820            }
7821
7822            // Decode unknown envelopes for gaps in ordinals.
7823            while _next_ordinal_to_read < 1 {
7824                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7825                _next_ordinal_to_read += 1;
7826                next_offset += envelope_size;
7827            }
7828
7829            let next_out_of_line = decoder.next_out_of_line();
7830            let handles_before = decoder.remaining_handles();
7831            if let Some((inlined, num_bytes, num_handles)) =
7832                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7833            {
7834                let member_inline_size = <fidl_fuchsia_bluetooth__common::LogicalTransportType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7835                if inlined != (member_inline_size <= 4) {
7836                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7837                }
7838                let inner_offset;
7839                let mut inner_depth = depth.clone();
7840                if inlined {
7841                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7842                    inner_offset = next_offset;
7843                } else {
7844                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7845                    inner_depth.increment()?;
7846                }
7847                let val_ref = self.logical_transport_type.get_or_insert_with(|| {
7848                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::LogicalTransportType, D)
7849                });
7850                fidl::decode!(
7851                    fidl_fuchsia_bluetooth__common::LogicalTransportType,
7852                    D,
7853                    val_ref,
7854                    decoder,
7855                    inner_offset,
7856                    inner_depth
7857                )?;
7858                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7859                {
7860                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7861                }
7862                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7863                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7864                }
7865            }
7866
7867            next_offset += envelope_size;
7868            _next_ordinal_to_read += 1;
7869            if next_offset >= end_offset {
7870                return Ok(());
7871            }
7872
7873            // Decode unknown envelopes for gaps in ordinals.
7874            while _next_ordinal_to_read < 2 {
7875                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7876                _next_ordinal_to_read += 1;
7877                next_offset += envelope_size;
7878            }
7879
7880            let next_out_of_line = decoder.next_out_of_line();
7881            let handles_before = decoder.remaining_handles();
7882            if let Some((inlined, num_bytes, num_handles)) =
7883                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7884            {
7885                let member_inline_size = <fidl_fuchsia_bluetooth__common::DataDirection as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7886                if inlined != (member_inline_size <= 4) {
7887                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7888                }
7889                let inner_offset;
7890                let mut inner_depth = depth.clone();
7891                if inlined {
7892                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7893                    inner_offset = next_offset;
7894                } else {
7895                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7896                    inner_depth.increment()?;
7897                }
7898                let val_ref = self.data_direction.get_or_insert_with(|| {
7899                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::DataDirection, D)
7900                });
7901                fidl::decode!(
7902                    fidl_fuchsia_bluetooth__common::DataDirection,
7903                    D,
7904                    val_ref,
7905                    decoder,
7906                    inner_offset,
7907                    inner_depth
7908                )?;
7909                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7910                {
7911                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7912                }
7913                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7914                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7915                }
7916            }
7917
7918            next_offset += envelope_size;
7919            _next_ordinal_to_read += 1;
7920            if next_offset >= end_offset {
7921                return Ok(());
7922            }
7923
7924            // Decode unknown envelopes for gaps in ordinals.
7925            while _next_ordinal_to_read < 3 {
7926                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7927                _next_ordinal_to_read += 1;
7928                next_offset += envelope_size;
7929            }
7930
7931            let next_out_of_line = decoder.next_out_of_line();
7932            let handles_before = decoder.remaining_handles();
7933            if let Some((inlined, num_bytes, num_handles)) =
7934                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7935            {
7936                let member_inline_size = <fidl_fuchsia_bluetooth__common::CodecAttributes as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7937                if inlined != (member_inline_size <= 4) {
7938                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7939                }
7940                let inner_offset;
7941                let mut inner_depth = depth.clone();
7942                if inlined {
7943                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7944                    inner_offset = next_offset;
7945                } else {
7946                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7947                    inner_depth.increment()?;
7948                }
7949                let val_ref = self.codec_attributes.get_or_insert_with(|| {
7950                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::CodecAttributes, D)
7951                });
7952                fidl::decode!(
7953                    fidl_fuchsia_bluetooth__common::CodecAttributes,
7954                    D,
7955                    val_ref,
7956                    decoder,
7957                    inner_offset,
7958                    inner_depth
7959                )?;
7960                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7961                {
7962                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7963                }
7964                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7965                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7966                }
7967            }
7968
7969            next_offset += envelope_size;
7970
7971            // Decode the remaining unknown envelopes.
7972            while next_offset < end_offset {
7973                _next_ordinal_to_read += 1;
7974                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7975                next_offset += envelope_size;
7976            }
7977
7978            Ok(())
7979        }
7980    }
7981
7982    impl CodecDelayGetCodecLocalDelayRangeResponse {
7983        #[inline(always)]
7984        fn max_ordinal_present(&self) -> u64 {
7985            if let Some(_) = self.max_controller_delay {
7986                return 2;
7987            }
7988            if let Some(_) = self.min_controller_delay {
7989                return 1;
7990            }
7991            0
7992        }
7993    }
7994
7995    impl fidl::encoding::ValueTypeMarker for CodecDelayGetCodecLocalDelayRangeResponse {
7996        type Borrowed<'a> = &'a Self;
7997        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7998            value
7999        }
8000    }
8001
8002    unsafe impl fidl::encoding::TypeMarker for CodecDelayGetCodecLocalDelayRangeResponse {
8003        type Owned = Self;
8004
8005        #[inline(always)]
8006        fn inline_align(_context: fidl::encoding::Context) -> usize {
8007            8
8008        }
8009
8010        #[inline(always)]
8011        fn inline_size(_context: fidl::encoding::Context) -> usize {
8012            16
8013        }
8014    }
8015
8016    unsafe impl<D: fidl::encoding::ResourceDialect>
8017        fidl::encoding::Encode<CodecDelayGetCodecLocalDelayRangeResponse, D>
8018        for &CodecDelayGetCodecLocalDelayRangeResponse
8019    {
8020        unsafe fn encode(
8021            self,
8022            encoder: &mut fidl::encoding::Encoder<'_, D>,
8023            offset: usize,
8024            mut depth: fidl::encoding::Depth,
8025        ) -> fidl::Result<()> {
8026            encoder.debug_check_bounds::<CodecDelayGetCodecLocalDelayRangeResponse>(offset);
8027            // Vector header
8028            let max_ordinal: u64 = self.max_ordinal_present();
8029            encoder.write_num(max_ordinal, offset);
8030            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8031            // Calling encoder.out_of_line_offset(0) is not allowed.
8032            if max_ordinal == 0 {
8033                return Ok(());
8034            }
8035            depth.increment()?;
8036            let envelope_size = 8;
8037            let bytes_len = max_ordinal as usize * envelope_size;
8038            #[allow(unused_variables)]
8039            let offset = encoder.out_of_line_offset(bytes_len);
8040            let mut _prev_end_offset: usize = 0;
8041            if 1 > max_ordinal {
8042                return Ok(());
8043            }
8044
8045            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8046            // are envelope_size bytes.
8047            let cur_offset: usize = (1 - 1) * envelope_size;
8048
8049            // Zero reserved fields.
8050            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8051
8052            // Safety:
8053            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8054            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8055            //   envelope_size bytes, there is always sufficient room.
8056            fidl::encoding::encode_in_envelope_optional::<i64, D>(
8057                self.min_controller_delay
8058                    .as_ref()
8059                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
8060                encoder,
8061                offset + cur_offset,
8062                depth,
8063            )?;
8064
8065            _prev_end_offset = cur_offset + envelope_size;
8066            if 2 > max_ordinal {
8067                return Ok(());
8068            }
8069
8070            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8071            // are envelope_size bytes.
8072            let cur_offset: usize = (2 - 1) * envelope_size;
8073
8074            // Zero reserved fields.
8075            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8076
8077            // Safety:
8078            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8079            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8080            //   envelope_size bytes, there is always sufficient room.
8081            fidl::encoding::encode_in_envelope_optional::<i64, D>(
8082                self.max_controller_delay
8083                    .as_ref()
8084                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
8085                encoder,
8086                offset + cur_offset,
8087                depth,
8088            )?;
8089
8090            _prev_end_offset = cur_offset + envelope_size;
8091
8092            Ok(())
8093        }
8094    }
8095
8096    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8097        for CodecDelayGetCodecLocalDelayRangeResponse
8098    {
8099        #[inline(always)]
8100        fn new_empty() -> Self {
8101            Self::default()
8102        }
8103
8104        unsafe fn decode(
8105            &mut self,
8106            decoder: &mut fidl::encoding::Decoder<'_, D>,
8107            offset: usize,
8108            mut depth: fidl::encoding::Depth,
8109        ) -> fidl::Result<()> {
8110            decoder.debug_check_bounds::<Self>(offset);
8111            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8112                None => return Err(fidl::Error::NotNullable),
8113                Some(len) => len,
8114            };
8115            // Calling decoder.out_of_line_offset(0) is not allowed.
8116            if len == 0 {
8117                return Ok(());
8118            };
8119            depth.increment()?;
8120            let envelope_size = 8;
8121            let bytes_len = len * envelope_size;
8122            let offset = decoder.out_of_line_offset(bytes_len)?;
8123            // Decode the envelope for each type.
8124            let mut _next_ordinal_to_read = 0;
8125            let mut next_offset = offset;
8126            let end_offset = offset + bytes_len;
8127            _next_ordinal_to_read += 1;
8128            if next_offset >= end_offset {
8129                return Ok(());
8130            }
8131
8132            // Decode unknown envelopes for gaps in ordinals.
8133            while _next_ordinal_to_read < 1 {
8134                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8135                _next_ordinal_to_read += 1;
8136                next_offset += envelope_size;
8137            }
8138
8139            let next_out_of_line = decoder.next_out_of_line();
8140            let handles_before = decoder.remaining_handles();
8141            if let Some((inlined, num_bytes, num_handles)) =
8142                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8143            {
8144                let member_inline_size =
8145                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8146                if inlined != (member_inline_size <= 4) {
8147                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8148                }
8149                let inner_offset;
8150                let mut inner_depth = depth.clone();
8151                if inlined {
8152                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8153                    inner_offset = next_offset;
8154                } else {
8155                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8156                    inner_depth.increment()?;
8157                }
8158                let val_ref =
8159                    self.min_controller_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
8160                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
8161                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8162                {
8163                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8164                }
8165                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8166                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8167                }
8168            }
8169
8170            next_offset += envelope_size;
8171            _next_ordinal_to_read += 1;
8172            if next_offset >= end_offset {
8173                return Ok(());
8174            }
8175
8176            // Decode unknown envelopes for gaps in ordinals.
8177            while _next_ordinal_to_read < 2 {
8178                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8179                _next_ordinal_to_read += 1;
8180                next_offset += envelope_size;
8181            }
8182
8183            let next_out_of_line = decoder.next_out_of_line();
8184            let handles_before = decoder.remaining_handles();
8185            if let Some((inlined, num_bytes, num_handles)) =
8186                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8187            {
8188                let member_inline_size =
8189                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8190                if inlined != (member_inline_size <= 4) {
8191                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8192                }
8193                let inner_offset;
8194                let mut inner_depth = depth.clone();
8195                if inlined {
8196                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8197                    inner_offset = next_offset;
8198                } else {
8199                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8200                    inner_depth.increment()?;
8201                }
8202                let val_ref =
8203                    self.max_controller_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
8204                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
8205                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8206                {
8207                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8208                }
8209                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8210                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8211                }
8212            }
8213
8214            next_offset += envelope_size;
8215
8216            // Decode the remaining unknown envelopes.
8217            while next_offset < end_offset {
8218                _next_ordinal_to_read += 1;
8219                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8220                next_offset += envelope_size;
8221            }
8222
8223            Ok(())
8224        }
8225    }
8226
8227    impl ConnectedIsochronousGroupEstablishStreamsRequest {
8228        #[inline(always)]
8229        fn max_ordinal_present(&self) -> u64 {
8230            if let Some(_) = self.cis_params {
8231                return 1;
8232            }
8233            0
8234        }
8235    }
8236
8237    impl fidl::encoding::ValueTypeMarker for ConnectedIsochronousGroupEstablishStreamsRequest {
8238        type Borrowed<'a> = &'a Self;
8239        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8240            value
8241        }
8242    }
8243
8244    unsafe impl fidl::encoding::TypeMarker for ConnectedIsochronousGroupEstablishStreamsRequest {
8245        type Owned = Self;
8246
8247        #[inline(always)]
8248        fn inline_align(_context: fidl::encoding::Context) -> usize {
8249            8
8250        }
8251
8252        #[inline(always)]
8253        fn inline_size(_context: fidl::encoding::Context) -> usize {
8254            16
8255        }
8256    }
8257
8258    unsafe impl<D: fidl::encoding::ResourceDialect>
8259        fidl::encoding::Encode<ConnectedIsochronousGroupEstablishStreamsRequest, D>
8260        for &ConnectedIsochronousGroupEstablishStreamsRequest
8261    {
8262        unsafe fn encode(
8263            self,
8264            encoder: &mut fidl::encoding::Encoder<'_, D>,
8265            offset: usize,
8266            mut depth: fidl::encoding::Depth,
8267        ) -> fidl::Result<()> {
8268            encoder.debug_check_bounds::<ConnectedIsochronousGroupEstablishStreamsRequest>(offset);
8269            // Vector header
8270            let max_ordinal: u64 = self.max_ordinal_present();
8271            encoder.write_num(max_ordinal, offset);
8272            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8273            // Calling encoder.out_of_line_offset(0) is not allowed.
8274            if max_ordinal == 0 {
8275                return Ok(());
8276            }
8277            depth.increment()?;
8278            let envelope_size = 8;
8279            let bytes_len = max_ordinal as usize * envelope_size;
8280            #[allow(unused_variables)]
8281            let offset = encoder.out_of_line_offset(bytes_len);
8282            let mut _prev_end_offset: usize = 0;
8283            if 1 > max_ordinal {
8284                return Ok(());
8285            }
8286
8287            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8288            // are envelope_size bytes.
8289            let cur_offset: usize = (1 - 1) * envelope_size;
8290
8291            // Zero reserved fields.
8292            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8293
8294            // Safety:
8295            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8296            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8297            //   envelope_size bytes, there is always sufficient room.
8298            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<CisParameters, 31>, D>(
8299            self.cis_params.as_ref().map(<fidl::encoding::Vector<CisParameters, 31> as fidl::encoding::ValueTypeMarker>::borrow),
8300            encoder, offset + cur_offset, depth
8301        )?;
8302
8303            _prev_end_offset = cur_offset + envelope_size;
8304
8305            Ok(())
8306        }
8307    }
8308
8309    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8310        for ConnectedIsochronousGroupEstablishStreamsRequest
8311    {
8312        #[inline(always)]
8313        fn new_empty() -> Self {
8314            Self::default()
8315        }
8316
8317        unsafe fn decode(
8318            &mut self,
8319            decoder: &mut fidl::encoding::Decoder<'_, D>,
8320            offset: usize,
8321            mut depth: fidl::encoding::Depth,
8322        ) -> fidl::Result<()> {
8323            decoder.debug_check_bounds::<Self>(offset);
8324            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8325                None => return Err(fidl::Error::NotNullable),
8326                Some(len) => len,
8327            };
8328            // Calling decoder.out_of_line_offset(0) is not allowed.
8329            if len == 0 {
8330                return Ok(());
8331            };
8332            depth.increment()?;
8333            let envelope_size = 8;
8334            let bytes_len = len * envelope_size;
8335            let offset = decoder.out_of_line_offset(bytes_len)?;
8336            // Decode the envelope for each type.
8337            let mut _next_ordinal_to_read = 0;
8338            let mut next_offset = offset;
8339            let end_offset = offset + bytes_len;
8340            _next_ordinal_to_read += 1;
8341            if next_offset >= end_offset {
8342                return Ok(());
8343            }
8344
8345            // Decode unknown envelopes for gaps in ordinals.
8346            while _next_ordinal_to_read < 1 {
8347                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8348                _next_ordinal_to_read += 1;
8349                next_offset += envelope_size;
8350            }
8351
8352            let next_out_of_line = decoder.next_out_of_line();
8353            let handles_before = decoder.remaining_handles();
8354            if let Some((inlined, num_bytes, num_handles)) =
8355                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8356            {
8357                let member_inline_size = <fidl::encoding::Vector<CisParameters, 31> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8358                if inlined != (member_inline_size <= 4) {
8359                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8360                }
8361                let inner_offset;
8362                let mut inner_depth = depth.clone();
8363                if inlined {
8364                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8365                    inner_offset = next_offset;
8366                } else {
8367                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8368                    inner_depth.increment()?;
8369                }
8370                let val_ref = self.cis_params.get_or_insert_with(
8371                    || fidl::new_empty!(fidl::encoding::Vector<CisParameters, 31>, D),
8372                );
8373                fidl::decode!(fidl::encoding::Vector<CisParameters, 31>, D, val_ref, decoder, inner_offset, inner_depth)?;
8374                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8375                {
8376                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8377                }
8378                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8379                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8380                }
8381            }
8382
8383            next_offset += envelope_size;
8384
8385            // Decode the remaining unknown envelopes.
8386            while next_offset < end_offset {
8387                _next_ordinal_to_read += 1;
8388                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8389                next_offset += envelope_size;
8390            }
8391
8392            Ok(())
8393        }
8394    }
8395
8396    impl ConnectionOptions {
8397        #[inline(always)]
8398        fn max_ordinal_present(&self) -> u64 {
8399            if let Some(_) = self.service_filter {
8400                return 2;
8401            }
8402            if let Some(_) = self.bondable_mode {
8403                return 1;
8404            }
8405            0
8406        }
8407    }
8408
8409    impl fidl::encoding::ValueTypeMarker for ConnectionOptions {
8410        type Borrowed<'a> = &'a Self;
8411        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8412            value
8413        }
8414    }
8415
8416    unsafe impl fidl::encoding::TypeMarker for ConnectionOptions {
8417        type Owned = Self;
8418
8419        #[inline(always)]
8420        fn inline_align(_context: fidl::encoding::Context) -> usize {
8421            8
8422        }
8423
8424        #[inline(always)]
8425        fn inline_size(_context: fidl::encoding::Context) -> usize {
8426            16
8427        }
8428    }
8429
8430    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConnectionOptions, D>
8431        for &ConnectionOptions
8432    {
8433        unsafe fn encode(
8434            self,
8435            encoder: &mut fidl::encoding::Encoder<'_, D>,
8436            offset: usize,
8437            mut depth: fidl::encoding::Depth,
8438        ) -> fidl::Result<()> {
8439            encoder.debug_check_bounds::<ConnectionOptions>(offset);
8440            // Vector header
8441            let max_ordinal: u64 = self.max_ordinal_present();
8442            encoder.write_num(max_ordinal, offset);
8443            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8444            // Calling encoder.out_of_line_offset(0) is not allowed.
8445            if max_ordinal == 0 {
8446                return Ok(());
8447            }
8448            depth.increment()?;
8449            let envelope_size = 8;
8450            let bytes_len = max_ordinal as usize * envelope_size;
8451            #[allow(unused_variables)]
8452            let offset = encoder.out_of_line_offset(bytes_len);
8453            let mut _prev_end_offset: usize = 0;
8454            if 1 > max_ordinal {
8455                return Ok(());
8456            }
8457
8458            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8459            // are envelope_size bytes.
8460            let cur_offset: usize = (1 - 1) * envelope_size;
8461
8462            // Zero reserved fields.
8463            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8464
8465            // Safety:
8466            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8467            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8468            //   envelope_size bytes, there is always sufficient room.
8469            fidl::encoding::encode_in_envelope_optional::<bool, D>(
8470                self.bondable_mode.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
8471                encoder,
8472                offset + cur_offset,
8473                depth,
8474            )?;
8475
8476            _prev_end_offset = cur_offset + envelope_size;
8477            if 2 > max_ordinal {
8478                return Ok(());
8479            }
8480
8481            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8482            // are envelope_size bytes.
8483            let cur_offset: usize = (2 - 1) * envelope_size;
8484
8485            // Zero reserved fields.
8486            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8487
8488            // Safety:
8489            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8490            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8491            //   envelope_size bytes, there is always sufficient room.
8492            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Uuid, D>(
8493            self.service_filter.as_ref().map(<fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow),
8494            encoder, offset + cur_offset, depth
8495        )?;
8496
8497            _prev_end_offset = cur_offset + envelope_size;
8498
8499            Ok(())
8500        }
8501    }
8502
8503    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectionOptions {
8504        #[inline(always)]
8505        fn new_empty() -> Self {
8506            Self::default()
8507        }
8508
8509        unsafe fn decode(
8510            &mut self,
8511            decoder: &mut fidl::encoding::Decoder<'_, D>,
8512            offset: usize,
8513            mut depth: fidl::encoding::Depth,
8514        ) -> fidl::Result<()> {
8515            decoder.debug_check_bounds::<Self>(offset);
8516            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8517                None => return Err(fidl::Error::NotNullable),
8518                Some(len) => len,
8519            };
8520            // Calling decoder.out_of_line_offset(0) is not allowed.
8521            if len == 0 {
8522                return Ok(());
8523            };
8524            depth.increment()?;
8525            let envelope_size = 8;
8526            let bytes_len = len * envelope_size;
8527            let offset = decoder.out_of_line_offset(bytes_len)?;
8528            // Decode the envelope for each type.
8529            let mut _next_ordinal_to_read = 0;
8530            let mut next_offset = offset;
8531            let end_offset = offset + bytes_len;
8532            _next_ordinal_to_read += 1;
8533            if next_offset >= end_offset {
8534                return Ok(());
8535            }
8536
8537            // Decode unknown envelopes for gaps in ordinals.
8538            while _next_ordinal_to_read < 1 {
8539                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8540                _next_ordinal_to_read += 1;
8541                next_offset += envelope_size;
8542            }
8543
8544            let next_out_of_line = decoder.next_out_of_line();
8545            let handles_before = decoder.remaining_handles();
8546            if let Some((inlined, num_bytes, num_handles)) =
8547                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8548            {
8549                let member_inline_size =
8550                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8551                if inlined != (member_inline_size <= 4) {
8552                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8553                }
8554                let inner_offset;
8555                let mut inner_depth = depth.clone();
8556                if inlined {
8557                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8558                    inner_offset = next_offset;
8559                } else {
8560                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8561                    inner_depth.increment()?;
8562                }
8563                let val_ref = self.bondable_mode.get_or_insert_with(|| fidl::new_empty!(bool, D));
8564                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
8565                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8566                {
8567                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8568                }
8569                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8570                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8571                }
8572            }
8573
8574            next_offset += envelope_size;
8575            _next_ordinal_to_read += 1;
8576            if next_offset >= end_offset {
8577                return Ok(());
8578            }
8579
8580            // Decode unknown envelopes for gaps in ordinals.
8581            while _next_ordinal_to_read < 2 {
8582                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8583                _next_ordinal_to_read += 1;
8584                next_offset += envelope_size;
8585            }
8586
8587            let next_out_of_line = decoder.next_out_of_line();
8588            let handles_before = decoder.remaining_handles();
8589            if let Some((inlined, num_bytes, num_handles)) =
8590                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8591            {
8592                let member_inline_size = <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8593                if inlined != (member_inline_size <= 4) {
8594                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8595                }
8596                let inner_offset;
8597                let mut inner_depth = depth.clone();
8598                if inlined {
8599                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8600                    inner_offset = next_offset;
8601                } else {
8602                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8603                    inner_depth.increment()?;
8604                }
8605                let val_ref = self.service_filter.get_or_insert_with(|| {
8606                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D)
8607                });
8608                fidl::decode!(
8609                    fidl_fuchsia_bluetooth__common::Uuid,
8610                    D,
8611                    val_ref,
8612                    decoder,
8613                    inner_offset,
8614                    inner_depth
8615                )?;
8616                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8617                {
8618                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8619                }
8620                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8621                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8622                }
8623            }
8624
8625            next_offset += envelope_size;
8626
8627            // Decode the remaining unknown envelopes.
8628            while next_offset < end_offset {
8629                _next_ordinal_to_read += 1;
8630                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8631                next_offset += envelope_size;
8632            }
8633
8634            Ok(())
8635        }
8636    }
8637
8638    impl Extended {
8639        #[inline(always)]
8640        fn max_ordinal_present(&self) -> u64 {
8641            0
8642        }
8643    }
8644
8645    impl fidl::encoding::ValueTypeMarker for Extended {
8646        type Borrowed<'a> = &'a Self;
8647        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8648            value
8649        }
8650    }
8651
8652    unsafe impl fidl::encoding::TypeMarker for Extended {
8653        type Owned = Self;
8654
8655        #[inline(always)]
8656        fn inline_align(_context: fidl::encoding::Context) -> usize {
8657            8
8658        }
8659
8660        #[inline(always)]
8661        fn inline_size(_context: fidl::encoding::Context) -> usize {
8662            16
8663        }
8664    }
8665
8666    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Extended, D> for &Extended {
8667        unsafe fn encode(
8668            self,
8669            encoder: &mut fidl::encoding::Encoder<'_, D>,
8670            offset: usize,
8671            mut depth: fidl::encoding::Depth,
8672        ) -> fidl::Result<()> {
8673            encoder.debug_check_bounds::<Extended>(offset);
8674            // Vector header
8675            let max_ordinal: u64 = self.max_ordinal_present();
8676            encoder.write_num(max_ordinal, offset);
8677            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8678            // Calling encoder.out_of_line_offset(0) is not allowed.
8679            if max_ordinal == 0 {
8680                return Ok(());
8681            }
8682            depth.increment()?;
8683            let envelope_size = 8;
8684            let bytes_len = max_ordinal as usize * envelope_size;
8685            #[allow(unused_variables)]
8686            let offset = encoder.out_of_line_offset(bytes_len);
8687            let mut _prev_end_offset: usize = 0;
8688
8689            Ok(())
8690        }
8691    }
8692
8693    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Extended {
8694        #[inline(always)]
8695        fn new_empty() -> Self {
8696            Self::default()
8697        }
8698
8699        unsafe fn decode(
8700            &mut self,
8701            decoder: &mut fidl::encoding::Decoder<'_, D>,
8702            offset: usize,
8703            mut depth: fidl::encoding::Depth,
8704        ) -> fidl::Result<()> {
8705            decoder.debug_check_bounds::<Self>(offset);
8706            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8707                None => return Err(fidl::Error::NotNullable),
8708                Some(len) => len,
8709            };
8710            // Calling decoder.out_of_line_offset(0) is not allowed.
8711            if len == 0 {
8712                return Ok(());
8713            };
8714            depth.increment()?;
8715            let envelope_size = 8;
8716            let bytes_len = len * envelope_size;
8717            let offset = decoder.out_of_line_offset(bytes_len)?;
8718            // Decode the envelope for each type.
8719            let mut _next_ordinal_to_read = 0;
8720            let mut next_offset = offset;
8721            let end_offset = offset + bytes_len;
8722
8723            // Decode the remaining unknown envelopes.
8724            while next_offset < end_offset {
8725                _next_ordinal_to_read += 1;
8726                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8727                next_offset += envelope_size;
8728            }
8729
8730            Ok(())
8731        }
8732    }
8733
8734    impl Filter {
8735        #[inline(always)]
8736        fn max_ordinal_present(&self) -> u64 {
8737            if let Some(_) = self.solicitation_uuid {
8738                return 7;
8739            }
8740            if let Some(_) = self.max_path_loss {
8741                return 6;
8742            }
8743            if let Some(_) = self.name {
8744                return 5;
8745            }
8746            if let Some(_) = self.connectable {
8747                return 4;
8748            }
8749            if let Some(_) = self.manufacturer_id {
8750                return 3;
8751            }
8752            if let Some(_) = self.service_data_uuid {
8753                return 2;
8754            }
8755            if let Some(_) = self.service_uuid {
8756                return 1;
8757            }
8758            0
8759        }
8760    }
8761
8762    impl fidl::encoding::ValueTypeMarker for Filter {
8763        type Borrowed<'a> = &'a Self;
8764        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8765            value
8766        }
8767    }
8768
8769    unsafe impl fidl::encoding::TypeMarker for Filter {
8770        type Owned = Self;
8771
8772        #[inline(always)]
8773        fn inline_align(_context: fidl::encoding::Context) -> usize {
8774            8
8775        }
8776
8777        #[inline(always)]
8778        fn inline_size(_context: fidl::encoding::Context) -> usize {
8779            16
8780        }
8781    }
8782
8783    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Filter, D> for &Filter {
8784        unsafe fn encode(
8785            self,
8786            encoder: &mut fidl::encoding::Encoder<'_, D>,
8787            offset: usize,
8788            mut depth: fidl::encoding::Depth,
8789        ) -> fidl::Result<()> {
8790            encoder.debug_check_bounds::<Filter>(offset);
8791            // Vector header
8792            let max_ordinal: u64 = self.max_ordinal_present();
8793            encoder.write_num(max_ordinal, offset);
8794            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8795            // Calling encoder.out_of_line_offset(0) is not allowed.
8796            if max_ordinal == 0 {
8797                return Ok(());
8798            }
8799            depth.increment()?;
8800            let envelope_size = 8;
8801            let bytes_len = max_ordinal as usize * envelope_size;
8802            #[allow(unused_variables)]
8803            let offset = encoder.out_of_line_offset(bytes_len);
8804            let mut _prev_end_offset: usize = 0;
8805            if 1 > max_ordinal {
8806                return Ok(());
8807            }
8808
8809            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8810            // are envelope_size bytes.
8811            let cur_offset: usize = (1 - 1) * envelope_size;
8812
8813            // Zero reserved fields.
8814            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8815
8816            // Safety:
8817            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8818            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8819            //   envelope_size bytes, there is always sufficient room.
8820            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Uuid, D>(
8821            self.service_uuid.as_ref().map(<fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow),
8822            encoder, offset + cur_offset, depth
8823        )?;
8824
8825            _prev_end_offset = cur_offset + envelope_size;
8826            if 2 > max_ordinal {
8827                return Ok(());
8828            }
8829
8830            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8831            // are envelope_size bytes.
8832            let cur_offset: usize = (2 - 1) * envelope_size;
8833
8834            // Zero reserved fields.
8835            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8836
8837            // Safety:
8838            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8839            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8840            //   envelope_size bytes, there is always sufficient room.
8841            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Uuid, D>(
8842            self.service_data_uuid.as_ref().map(<fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow),
8843            encoder, offset + cur_offset, depth
8844        )?;
8845
8846            _prev_end_offset = cur_offset + envelope_size;
8847            if 3 > max_ordinal {
8848                return Ok(());
8849            }
8850
8851            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8852            // are envelope_size bytes.
8853            let cur_offset: usize = (3 - 1) * envelope_size;
8854
8855            // Zero reserved fields.
8856            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8857
8858            // Safety:
8859            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8860            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8861            //   envelope_size bytes, there is always sufficient room.
8862            fidl::encoding::encode_in_envelope_optional::<u16, D>(
8863                self.manufacturer_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
8864                encoder,
8865                offset + cur_offset,
8866                depth,
8867            )?;
8868
8869            _prev_end_offset = cur_offset + envelope_size;
8870            if 4 > max_ordinal {
8871                return Ok(());
8872            }
8873
8874            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8875            // are envelope_size bytes.
8876            let cur_offset: usize = (4 - 1) * envelope_size;
8877
8878            // Zero reserved fields.
8879            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8880
8881            // Safety:
8882            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8883            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8884            //   envelope_size bytes, there is always sufficient room.
8885            fidl::encoding::encode_in_envelope_optional::<bool, D>(
8886                self.connectable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
8887                encoder,
8888                offset + cur_offset,
8889                depth,
8890            )?;
8891
8892            _prev_end_offset = cur_offset + envelope_size;
8893            if 5 > max_ordinal {
8894                return Ok(());
8895            }
8896
8897            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8898            // are envelope_size bytes.
8899            let cur_offset: usize = (5 - 1) * envelope_size;
8900
8901            // Zero reserved fields.
8902            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8903
8904            // Safety:
8905            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8906            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8907            //   envelope_size bytes, there is always sufficient room.
8908            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<248>, D>(
8909                self.name.as_ref().map(
8910                    <fidl::encoding::BoundedString<248> as fidl::encoding::ValueTypeMarker>::borrow,
8911                ),
8912                encoder,
8913                offset + cur_offset,
8914                depth,
8915            )?;
8916
8917            _prev_end_offset = cur_offset + envelope_size;
8918            if 6 > max_ordinal {
8919                return Ok(());
8920            }
8921
8922            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8923            // are envelope_size bytes.
8924            let cur_offset: usize = (6 - 1) * envelope_size;
8925
8926            // Zero reserved fields.
8927            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8928
8929            // Safety:
8930            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8931            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8932            //   envelope_size bytes, there is always sufficient room.
8933            fidl::encoding::encode_in_envelope_optional::<i8, D>(
8934                self.max_path_loss.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
8935                encoder,
8936                offset + cur_offset,
8937                depth,
8938            )?;
8939
8940            _prev_end_offset = cur_offset + envelope_size;
8941            if 7 > max_ordinal {
8942                return Ok(());
8943            }
8944
8945            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8946            // are envelope_size bytes.
8947            let cur_offset: usize = (7 - 1) * envelope_size;
8948
8949            // Zero reserved fields.
8950            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8951
8952            // Safety:
8953            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8954            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8955            //   envelope_size bytes, there is always sufficient room.
8956            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Uuid, D>(
8957            self.solicitation_uuid.as_ref().map(<fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow),
8958            encoder, offset + cur_offset, depth
8959        )?;
8960
8961            _prev_end_offset = cur_offset + envelope_size;
8962
8963            Ok(())
8964        }
8965    }
8966
8967    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Filter {
8968        #[inline(always)]
8969        fn new_empty() -> Self {
8970            Self::default()
8971        }
8972
8973        unsafe fn decode(
8974            &mut self,
8975            decoder: &mut fidl::encoding::Decoder<'_, D>,
8976            offset: usize,
8977            mut depth: fidl::encoding::Depth,
8978        ) -> fidl::Result<()> {
8979            decoder.debug_check_bounds::<Self>(offset);
8980            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8981                None => return Err(fidl::Error::NotNullable),
8982                Some(len) => len,
8983            };
8984            // Calling decoder.out_of_line_offset(0) is not allowed.
8985            if len == 0 {
8986                return Ok(());
8987            };
8988            depth.increment()?;
8989            let envelope_size = 8;
8990            let bytes_len = len * envelope_size;
8991            let offset = decoder.out_of_line_offset(bytes_len)?;
8992            // Decode the envelope for each type.
8993            let mut _next_ordinal_to_read = 0;
8994            let mut next_offset = offset;
8995            let end_offset = offset + bytes_len;
8996            _next_ordinal_to_read += 1;
8997            if next_offset >= end_offset {
8998                return Ok(());
8999            }
9000
9001            // Decode unknown envelopes for gaps in ordinals.
9002            while _next_ordinal_to_read < 1 {
9003                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9004                _next_ordinal_to_read += 1;
9005                next_offset += envelope_size;
9006            }
9007
9008            let next_out_of_line = decoder.next_out_of_line();
9009            let handles_before = decoder.remaining_handles();
9010            if let Some((inlined, num_bytes, num_handles)) =
9011                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9012            {
9013                let member_inline_size = <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9014                if inlined != (member_inline_size <= 4) {
9015                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9016                }
9017                let inner_offset;
9018                let mut inner_depth = depth.clone();
9019                if inlined {
9020                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9021                    inner_offset = next_offset;
9022                } else {
9023                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9024                    inner_depth.increment()?;
9025                }
9026                let val_ref = self.service_uuid.get_or_insert_with(|| {
9027                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D)
9028                });
9029                fidl::decode!(
9030                    fidl_fuchsia_bluetooth__common::Uuid,
9031                    D,
9032                    val_ref,
9033                    decoder,
9034                    inner_offset,
9035                    inner_depth
9036                )?;
9037                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9038                {
9039                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9040                }
9041                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9042                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9043                }
9044            }
9045
9046            next_offset += envelope_size;
9047            _next_ordinal_to_read += 1;
9048            if next_offset >= end_offset {
9049                return Ok(());
9050            }
9051
9052            // Decode unknown envelopes for gaps in ordinals.
9053            while _next_ordinal_to_read < 2 {
9054                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9055                _next_ordinal_to_read += 1;
9056                next_offset += envelope_size;
9057            }
9058
9059            let next_out_of_line = decoder.next_out_of_line();
9060            let handles_before = decoder.remaining_handles();
9061            if let Some((inlined, num_bytes, num_handles)) =
9062                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9063            {
9064                let member_inline_size = <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9065                if inlined != (member_inline_size <= 4) {
9066                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9067                }
9068                let inner_offset;
9069                let mut inner_depth = depth.clone();
9070                if inlined {
9071                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9072                    inner_offset = next_offset;
9073                } else {
9074                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9075                    inner_depth.increment()?;
9076                }
9077                let val_ref = self.service_data_uuid.get_or_insert_with(|| {
9078                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D)
9079                });
9080                fidl::decode!(
9081                    fidl_fuchsia_bluetooth__common::Uuid,
9082                    D,
9083                    val_ref,
9084                    decoder,
9085                    inner_offset,
9086                    inner_depth
9087                )?;
9088                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9089                {
9090                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9091                }
9092                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9093                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9094                }
9095            }
9096
9097            next_offset += envelope_size;
9098            _next_ordinal_to_read += 1;
9099            if next_offset >= end_offset {
9100                return Ok(());
9101            }
9102
9103            // Decode unknown envelopes for gaps in ordinals.
9104            while _next_ordinal_to_read < 3 {
9105                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9106                _next_ordinal_to_read += 1;
9107                next_offset += envelope_size;
9108            }
9109
9110            let next_out_of_line = decoder.next_out_of_line();
9111            let handles_before = decoder.remaining_handles();
9112            if let Some((inlined, num_bytes, num_handles)) =
9113                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9114            {
9115                let member_inline_size =
9116                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9117                if inlined != (member_inline_size <= 4) {
9118                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9119                }
9120                let inner_offset;
9121                let mut inner_depth = depth.clone();
9122                if inlined {
9123                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9124                    inner_offset = next_offset;
9125                } else {
9126                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9127                    inner_depth.increment()?;
9128                }
9129                let val_ref = self.manufacturer_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
9130                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
9131                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9132                {
9133                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9134                }
9135                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9136                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9137                }
9138            }
9139
9140            next_offset += envelope_size;
9141            _next_ordinal_to_read += 1;
9142            if next_offset >= end_offset {
9143                return Ok(());
9144            }
9145
9146            // Decode unknown envelopes for gaps in ordinals.
9147            while _next_ordinal_to_read < 4 {
9148                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9149                _next_ordinal_to_read += 1;
9150                next_offset += envelope_size;
9151            }
9152
9153            let next_out_of_line = decoder.next_out_of_line();
9154            let handles_before = decoder.remaining_handles();
9155            if let Some((inlined, num_bytes, num_handles)) =
9156                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9157            {
9158                let member_inline_size =
9159                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9160                if inlined != (member_inline_size <= 4) {
9161                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9162                }
9163                let inner_offset;
9164                let mut inner_depth = depth.clone();
9165                if inlined {
9166                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9167                    inner_offset = next_offset;
9168                } else {
9169                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9170                    inner_depth.increment()?;
9171                }
9172                let val_ref = self.connectable.get_or_insert_with(|| fidl::new_empty!(bool, D));
9173                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9174                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9175                {
9176                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9177                }
9178                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9179                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9180                }
9181            }
9182
9183            next_offset += envelope_size;
9184            _next_ordinal_to_read += 1;
9185            if next_offset >= end_offset {
9186                return Ok(());
9187            }
9188
9189            // Decode unknown envelopes for gaps in ordinals.
9190            while _next_ordinal_to_read < 5 {
9191                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9192                _next_ordinal_to_read += 1;
9193                next_offset += envelope_size;
9194            }
9195
9196            let next_out_of_line = decoder.next_out_of_line();
9197            let handles_before = decoder.remaining_handles();
9198            if let Some((inlined, num_bytes, num_handles)) =
9199                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9200            {
9201                let member_inline_size =
9202                    <fidl::encoding::BoundedString<248> as fidl::encoding::TypeMarker>::inline_size(
9203                        decoder.context,
9204                    );
9205                if inlined != (member_inline_size <= 4) {
9206                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9207                }
9208                let inner_offset;
9209                let mut inner_depth = depth.clone();
9210                if inlined {
9211                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9212                    inner_offset = next_offset;
9213                } else {
9214                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9215                    inner_depth.increment()?;
9216                }
9217                let val_ref = self
9218                    .name
9219                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<248>, D));
9220                fidl::decode!(
9221                    fidl::encoding::BoundedString<248>,
9222                    D,
9223                    val_ref,
9224                    decoder,
9225                    inner_offset,
9226                    inner_depth
9227                )?;
9228                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9229                {
9230                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9231                }
9232                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9233                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9234                }
9235            }
9236
9237            next_offset += envelope_size;
9238            _next_ordinal_to_read += 1;
9239            if next_offset >= end_offset {
9240                return Ok(());
9241            }
9242
9243            // Decode unknown envelopes for gaps in ordinals.
9244            while _next_ordinal_to_read < 6 {
9245                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9246                _next_ordinal_to_read += 1;
9247                next_offset += envelope_size;
9248            }
9249
9250            let next_out_of_line = decoder.next_out_of_line();
9251            let handles_before = decoder.remaining_handles();
9252            if let Some((inlined, num_bytes, num_handles)) =
9253                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9254            {
9255                let member_inline_size =
9256                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9257                if inlined != (member_inline_size <= 4) {
9258                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9259                }
9260                let inner_offset;
9261                let mut inner_depth = depth.clone();
9262                if inlined {
9263                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9264                    inner_offset = next_offset;
9265                } else {
9266                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9267                    inner_depth.increment()?;
9268                }
9269                let val_ref = self.max_path_loss.get_or_insert_with(|| fidl::new_empty!(i8, D));
9270                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
9271                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9272                {
9273                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9274                }
9275                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9276                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9277                }
9278            }
9279
9280            next_offset += envelope_size;
9281            _next_ordinal_to_read += 1;
9282            if next_offset >= end_offset {
9283                return Ok(());
9284            }
9285
9286            // Decode unknown envelopes for gaps in ordinals.
9287            while _next_ordinal_to_read < 7 {
9288                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9289                _next_ordinal_to_read += 1;
9290                next_offset += envelope_size;
9291            }
9292
9293            let next_out_of_line = decoder.next_out_of_line();
9294            let handles_before = decoder.remaining_handles();
9295            if let Some((inlined, num_bytes, num_handles)) =
9296                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9297            {
9298                let member_inline_size = <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9299                if inlined != (member_inline_size <= 4) {
9300                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9301                }
9302                let inner_offset;
9303                let mut inner_depth = depth.clone();
9304                if inlined {
9305                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9306                    inner_offset = next_offset;
9307                } else {
9308                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9309                    inner_depth.increment()?;
9310                }
9311                let val_ref = self.solicitation_uuid.get_or_insert_with(|| {
9312                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D)
9313                });
9314                fidl::decode!(
9315                    fidl_fuchsia_bluetooth__common::Uuid,
9316                    D,
9317                    val_ref,
9318                    decoder,
9319                    inner_offset,
9320                    inner_depth
9321                )?;
9322                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9323                {
9324                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9325                }
9326                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9327                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9328                }
9329            }
9330
9331            next_offset += envelope_size;
9332
9333            // Decode the remaining unknown envelopes.
9334            while next_offset < end_offset {
9335                _next_ordinal_to_read += 1;
9336                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9337                next_offset += envelope_size;
9338            }
9339
9340            Ok(())
9341        }
9342    }
9343
9344    impl IsochronousStreamOnEstablishedRequest {
9345        #[inline(always)]
9346        fn max_ordinal_present(&self) -> u64 {
9347            if let Some(_) = self.established_params {
9348                return 2;
9349            }
9350            if let Some(_) = self.result {
9351                return 1;
9352            }
9353            0
9354        }
9355    }
9356
9357    impl fidl::encoding::ValueTypeMarker for IsochronousStreamOnEstablishedRequest {
9358        type Borrowed<'a> = &'a Self;
9359        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9360            value
9361        }
9362    }
9363
9364    unsafe impl fidl::encoding::TypeMarker for IsochronousStreamOnEstablishedRequest {
9365        type Owned = Self;
9366
9367        #[inline(always)]
9368        fn inline_align(_context: fidl::encoding::Context) -> usize {
9369            8
9370        }
9371
9372        #[inline(always)]
9373        fn inline_size(_context: fidl::encoding::Context) -> usize {
9374            16
9375        }
9376    }
9377
9378    unsafe impl<D: fidl::encoding::ResourceDialect>
9379        fidl::encoding::Encode<IsochronousStreamOnEstablishedRequest, D>
9380        for &IsochronousStreamOnEstablishedRequest
9381    {
9382        unsafe fn encode(
9383            self,
9384            encoder: &mut fidl::encoding::Encoder<'_, D>,
9385            offset: usize,
9386            mut depth: fidl::encoding::Depth,
9387        ) -> fidl::Result<()> {
9388            encoder.debug_check_bounds::<IsochronousStreamOnEstablishedRequest>(offset);
9389            // Vector header
9390            let max_ordinal: u64 = self.max_ordinal_present();
9391            encoder.write_num(max_ordinal, offset);
9392            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9393            // Calling encoder.out_of_line_offset(0) is not allowed.
9394            if max_ordinal == 0 {
9395                return Ok(());
9396            }
9397            depth.increment()?;
9398            let envelope_size = 8;
9399            let bytes_len = max_ordinal as usize * envelope_size;
9400            #[allow(unused_variables)]
9401            let offset = encoder.out_of_line_offset(bytes_len);
9402            let mut _prev_end_offset: usize = 0;
9403            if 1 > max_ordinal {
9404                return Ok(());
9405            }
9406
9407            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9408            // are envelope_size bytes.
9409            let cur_offset: usize = (1 - 1) * envelope_size;
9410
9411            // Zero reserved fields.
9412            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9413
9414            // Safety:
9415            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9416            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9417            //   envelope_size bytes, there is always sufficient room.
9418            fidl::encoding::encode_in_envelope_optional::<i32, D>(
9419                self.result.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
9420                encoder,
9421                offset + cur_offset,
9422                depth,
9423            )?;
9424
9425            _prev_end_offset = cur_offset + envelope_size;
9426            if 2 > max_ordinal {
9427                return Ok(());
9428            }
9429
9430            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9431            // are envelope_size bytes.
9432            let cur_offset: usize = (2 - 1) * envelope_size;
9433
9434            // Zero reserved fields.
9435            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9436
9437            // Safety:
9438            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9439            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9440            //   envelope_size bytes, there is always sufficient room.
9441            fidl::encoding::encode_in_envelope_optional::<CisEstablishedParameters, D>(
9442                self.established_params
9443                    .as_ref()
9444                    .map(<CisEstablishedParameters as fidl::encoding::ValueTypeMarker>::borrow),
9445                encoder,
9446                offset + cur_offset,
9447                depth,
9448            )?;
9449
9450            _prev_end_offset = cur_offset + envelope_size;
9451
9452            Ok(())
9453        }
9454    }
9455
9456    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9457        for IsochronousStreamOnEstablishedRequest
9458    {
9459        #[inline(always)]
9460        fn new_empty() -> Self {
9461            Self::default()
9462        }
9463
9464        unsafe fn decode(
9465            &mut self,
9466            decoder: &mut fidl::encoding::Decoder<'_, D>,
9467            offset: usize,
9468            mut depth: fidl::encoding::Depth,
9469        ) -> fidl::Result<()> {
9470            decoder.debug_check_bounds::<Self>(offset);
9471            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9472                None => return Err(fidl::Error::NotNullable),
9473                Some(len) => len,
9474            };
9475            // Calling decoder.out_of_line_offset(0) is not allowed.
9476            if len == 0 {
9477                return Ok(());
9478            };
9479            depth.increment()?;
9480            let envelope_size = 8;
9481            let bytes_len = len * envelope_size;
9482            let offset = decoder.out_of_line_offset(bytes_len)?;
9483            // Decode the envelope for each type.
9484            let mut _next_ordinal_to_read = 0;
9485            let mut next_offset = offset;
9486            let end_offset = offset + bytes_len;
9487            _next_ordinal_to_read += 1;
9488            if next_offset >= end_offset {
9489                return Ok(());
9490            }
9491
9492            // Decode unknown envelopes for gaps in ordinals.
9493            while _next_ordinal_to_read < 1 {
9494                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9495                _next_ordinal_to_read += 1;
9496                next_offset += envelope_size;
9497            }
9498
9499            let next_out_of_line = decoder.next_out_of_line();
9500            let handles_before = decoder.remaining_handles();
9501            if let Some((inlined, num_bytes, num_handles)) =
9502                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9503            {
9504                let member_inline_size =
9505                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9506                if inlined != (member_inline_size <= 4) {
9507                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9508                }
9509                let inner_offset;
9510                let mut inner_depth = depth.clone();
9511                if inlined {
9512                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9513                    inner_offset = next_offset;
9514                } else {
9515                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9516                    inner_depth.increment()?;
9517                }
9518                let val_ref = self.result.get_or_insert_with(|| fidl::new_empty!(i32, D));
9519                fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
9520                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9521                {
9522                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9523                }
9524                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9525                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9526                }
9527            }
9528
9529            next_offset += envelope_size;
9530            _next_ordinal_to_read += 1;
9531            if next_offset >= end_offset {
9532                return Ok(());
9533            }
9534
9535            // Decode unknown envelopes for gaps in ordinals.
9536            while _next_ordinal_to_read < 2 {
9537                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9538                _next_ordinal_to_read += 1;
9539                next_offset += envelope_size;
9540            }
9541
9542            let next_out_of_line = decoder.next_out_of_line();
9543            let handles_before = decoder.remaining_handles();
9544            if let Some((inlined, num_bytes, num_handles)) =
9545                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9546            {
9547                let member_inline_size =
9548                    <CisEstablishedParameters as fidl::encoding::TypeMarker>::inline_size(
9549                        decoder.context,
9550                    );
9551                if inlined != (member_inline_size <= 4) {
9552                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9553                }
9554                let inner_offset;
9555                let mut inner_depth = depth.clone();
9556                if inlined {
9557                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9558                    inner_offset = next_offset;
9559                } else {
9560                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9561                    inner_depth.increment()?;
9562                }
9563                let val_ref = self
9564                    .established_params
9565                    .get_or_insert_with(|| fidl::new_empty!(CisEstablishedParameters, D));
9566                fidl::decode!(
9567                    CisEstablishedParameters,
9568                    D,
9569                    val_ref,
9570                    decoder,
9571                    inner_offset,
9572                    inner_depth
9573                )?;
9574                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9575                {
9576                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9577                }
9578                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9579                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9580                }
9581            }
9582
9583            next_offset += envelope_size;
9584
9585            // Decode the remaining unknown envelopes.
9586            while next_offset < end_offset {
9587                _next_ordinal_to_read += 1;
9588                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9589                next_offset += envelope_size;
9590            }
9591
9592            Ok(())
9593        }
9594    }
9595
9596    impl IsochronousStreamSetupDataPathRequest {
9597        #[inline(always)]
9598        fn max_ordinal_present(&self) -> u64 {
9599            if let Some(_) = self.controller_delay {
9600                return 3;
9601            }
9602            if let Some(_) = self.codec_attributes {
9603                return 2;
9604            }
9605            if let Some(_) = self.data_direction {
9606                return 1;
9607            }
9608            0
9609        }
9610    }
9611
9612    impl fidl::encoding::ValueTypeMarker for IsochronousStreamSetupDataPathRequest {
9613        type Borrowed<'a> = &'a Self;
9614        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9615            value
9616        }
9617    }
9618
9619    unsafe impl fidl::encoding::TypeMarker for IsochronousStreamSetupDataPathRequest {
9620        type Owned = Self;
9621
9622        #[inline(always)]
9623        fn inline_align(_context: fidl::encoding::Context) -> usize {
9624            8
9625        }
9626
9627        #[inline(always)]
9628        fn inline_size(_context: fidl::encoding::Context) -> usize {
9629            16
9630        }
9631    }
9632
9633    unsafe impl<D: fidl::encoding::ResourceDialect>
9634        fidl::encoding::Encode<IsochronousStreamSetupDataPathRequest, D>
9635        for &IsochronousStreamSetupDataPathRequest
9636    {
9637        unsafe fn encode(
9638            self,
9639            encoder: &mut fidl::encoding::Encoder<'_, D>,
9640            offset: usize,
9641            mut depth: fidl::encoding::Depth,
9642        ) -> fidl::Result<()> {
9643            encoder.debug_check_bounds::<IsochronousStreamSetupDataPathRequest>(offset);
9644            // Vector header
9645            let max_ordinal: u64 = self.max_ordinal_present();
9646            encoder.write_num(max_ordinal, offset);
9647            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9648            // Calling encoder.out_of_line_offset(0) is not allowed.
9649            if max_ordinal == 0 {
9650                return Ok(());
9651            }
9652            depth.increment()?;
9653            let envelope_size = 8;
9654            let bytes_len = max_ordinal as usize * envelope_size;
9655            #[allow(unused_variables)]
9656            let offset = encoder.out_of_line_offset(bytes_len);
9657            let mut _prev_end_offset: usize = 0;
9658            if 1 > max_ordinal {
9659                return Ok(());
9660            }
9661
9662            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9663            // are envelope_size bytes.
9664            let cur_offset: usize = (1 - 1) * envelope_size;
9665
9666            // Zero reserved fields.
9667            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9668
9669            // Safety:
9670            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9671            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9672            //   envelope_size bytes, there is always sufficient room.
9673            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::DataDirection, D>(
9674            self.data_direction.as_ref().map(<fidl_fuchsia_bluetooth__common::DataDirection as fidl::encoding::ValueTypeMarker>::borrow),
9675            encoder, offset + cur_offset, depth
9676        )?;
9677
9678            _prev_end_offset = cur_offset + envelope_size;
9679            if 2 > max_ordinal {
9680                return Ok(());
9681            }
9682
9683            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9684            // are envelope_size bytes.
9685            let cur_offset: usize = (2 - 1) * envelope_size;
9686
9687            // Zero reserved fields.
9688            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9689
9690            // Safety:
9691            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9692            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9693            //   envelope_size bytes, there is always sufficient room.
9694            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::CodecAttributes, D>(
9695            self.codec_attributes.as_ref().map(<fidl_fuchsia_bluetooth__common::CodecAttributes as fidl::encoding::ValueTypeMarker>::borrow),
9696            encoder, offset + cur_offset, depth
9697        )?;
9698
9699            _prev_end_offset = cur_offset + envelope_size;
9700            if 3 > max_ordinal {
9701                return Ok(());
9702            }
9703
9704            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9705            // are envelope_size bytes.
9706            let cur_offset: usize = (3 - 1) * envelope_size;
9707
9708            // Zero reserved fields.
9709            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9710
9711            // Safety:
9712            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9713            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9714            //   envelope_size bytes, there is always sufficient room.
9715            fidl::encoding::encode_in_envelope_optional::<i64, D>(
9716                self.controller_delay
9717                    .as_ref()
9718                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
9719                encoder,
9720                offset + cur_offset,
9721                depth,
9722            )?;
9723
9724            _prev_end_offset = cur_offset + envelope_size;
9725
9726            Ok(())
9727        }
9728    }
9729
9730    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9731        for IsochronousStreamSetupDataPathRequest
9732    {
9733        #[inline(always)]
9734        fn new_empty() -> Self {
9735            Self::default()
9736        }
9737
9738        unsafe fn decode(
9739            &mut self,
9740            decoder: &mut fidl::encoding::Decoder<'_, D>,
9741            offset: usize,
9742            mut depth: fidl::encoding::Depth,
9743        ) -> fidl::Result<()> {
9744            decoder.debug_check_bounds::<Self>(offset);
9745            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9746                None => return Err(fidl::Error::NotNullable),
9747                Some(len) => len,
9748            };
9749            // Calling decoder.out_of_line_offset(0) is not allowed.
9750            if len == 0 {
9751                return Ok(());
9752            };
9753            depth.increment()?;
9754            let envelope_size = 8;
9755            let bytes_len = len * envelope_size;
9756            let offset = decoder.out_of_line_offset(bytes_len)?;
9757            // Decode the envelope for each type.
9758            let mut _next_ordinal_to_read = 0;
9759            let mut next_offset = offset;
9760            let end_offset = offset + bytes_len;
9761            _next_ordinal_to_read += 1;
9762            if next_offset >= end_offset {
9763                return Ok(());
9764            }
9765
9766            // Decode unknown envelopes for gaps in ordinals.
9767            while _next_ordinal_to_read < 1 {
9768                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9769                _next_ordinal_to_read += 1;
9770                next_offset += envelope_size;
9771            }
9772
9773            let next_out_of_line = decoder.next_out_of_line();
9774            let handles_before = decoder.remaining_handles();
9775            if let Some((inlined, num_bytes, num_handles)) =
9776                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9777            {
9778                let member_inline_size = <fidl_fuchsia_bluetooth__common::DataDirection as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9779                if inlined != (member_inline_size <= 4) {
9780                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9781                }
9782                let inner_offset;
9783                let mut inner_depth = depth.clone();
9784                if inlined {
9785                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9786                    inner_offset = next_offset;
9787                } else {
9788                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9789                    inner_depth.increment()?;
9790                }
9791                let val_ref = self.data_direction.get_or_insert_with(|| {
9792                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::DataDirection, D)
9793                });
9794                fidl::decode!(
9795                    fidl_fuchsia_bluetooth__common::DataDirection,
9796                    D,
9797                    val_ref,
9798                    decoder,
9799                    inner_offset,
9800                    inner_depth
9801                )?;
9802                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9803                {
9804                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9805                }
9806                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9807                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9808                }
9809            }
9810
9811            next_offset += envelope_size;
9812            _next_ordinal_to_read += 1;
9813            if next_offset >= end_offset {
9814                return Ok(());
9815            }
9816
9817            // Decode unknown envelopes for gaps in ordinals.
9818            while _next_ordinal_to_read < 2 {
9819                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9820                _next_ordinal_to_read += 1;
9821                next_offset += envelope_size;
9822            }
9823
9824            let next_out_of_line = decoder.next_out_of_line();
9825            let handles_before = decoder.remaining_handles();
9826            if let Some((inlined, num_bytes, num_handles)) =
9827                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9828            {
9829                let member_inline_size = <fidl_fuchsia_bluetooth__common::CodecAttributes as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9830                if inlined != (member_inline_size <= 4) {
9831                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9832                }
9833                let inner_offset;
9834                let mut inner_depth = depth.clone();
9835                if inlined {
9836                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9837                    inner_offset = next_offset;
9838                } else {
9839                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9840                    inner_depth.increment()?;
9841                }
9842                let val_ref = self.codec_attributes.get_or_insert_with(|| {
9843                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::CodecAttributes, D)
9844                });
9845                fidl::decode!(
9846                    fidl_fuchsia_bluetooth__common::CodecAttributes,
9847                    D,
9848                    val_ref,
9849                    decoder,
9850                    inner_offset,
9851                    inner_depth
9852                )?;
9853                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9854                {
9855                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9856                }
9857                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9858                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9859                }
9860            }
9861
9862            next_offset += envelope_size;
9863            _next_ordinal_to_read += 1;
9864            if next_offset >= end_offset {
9865                return Ok(());
9866            }
9867
9868            // Decode unknown envelopes for gaps in ordinals.
9869            while _next_ordinal_to_read < 3 {
9870                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9871                _next_ordinal_to_read += 1;
9872                next_offset += envelope_size;
9873            }
9874
9875            let next_out_of_line = decoder.next_out_of_line();
9876            let handles_before = decoder.remaining_handles();
9877            if let Some((inlined, num_bytes, num_handles)) =
9878                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9879            {
9880                let member_inline_size =
9881                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9882                if inlined != (member_inline_size <= 4) {
9883                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9884                }
9885                let inner_offset;
9886                let mut inner_depth = depth.clone();
9887                if inlined {
9888                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9889                    inner_offset = next_offset;
9890                } else {
9891                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9892                    inner_depth.increment()?;
9893                }
9894                let val_ref = self.controller_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
9895                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
9896                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9897                {
9898                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9899                }
9900                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9901                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9902                }
9903            }
9904
9905            next_offset += envelope_size;
9906
9907            // Decode the remaining unknown envelopes.
9908            while next_offset < end_offset {
9909                _next_ordinal_to_read += 1;
9910                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9911                next_offset += envelope_size;
9912            }
9913
9914            Ok(())
9915        }
9916    }
9917
9918    impl IsochronousStreamWriteRequest {
9919        #[inline(always)]
9920        fn max_ordinal_present(&self) -> u64 {
9921            if let Some(_) = self.data {
9922                return 1;
9923            }
9924            0
9925        }
9926    }
9927
9928    impl fidl::encoding::ValueTypeMarker for IsochronousStreamWriteRequest {
9929        type Borrowed<'a> = &'a Self;
9930        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9931            value
9932        }
9933    }
9934
9935    unsafe impl fidl::encoding::TypeMarker for IsochronousStreamWriteRequest {
9936        type Owned = Self;
9937
9938        #[inline(always)]
9939        fn inline_align(_context: fidl::encoding::Context) -> usize {
9940            8
9941        }
9942
9943        #[inline(always)]
9944        fn inline_size(_context: fidl::encoding::Context) -> usize {
9945            16
9946        }
9947    }
9948
9949    unsafe impl<D: fidl::encoding::ResourceDialect>
9950        fidl::encoding::Encode<IsochronousStreamWriteRequest, D>
9951        for &IsochronousStreamWriteRequest
9952    {
9953        unsafe fn encode(
9954            self,
9955            encoder: &mut fidl::encoding::Encoder<'_, D>,
9956            offset: usize,
9957            mut depth: fidl::encoding::Depth,
9958        ) -> fidl::Result<()> {
9959            encoder.debug_check_bounds::<IsochronousStreamWriteRequest>(offset);
9960            // Vector header
9961            let max_ordinal: u64 = self.max_ordinal_present();
9962            encoder.write_num(max_ordinal, offset);
9963            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9964            // Calling encoder.out_of_line_offset(0) is not allowed.
9965            if max_ordinal == 0 {
9966                return Ok(());
9967            }
9968            depth.increment()?;
9969            let envelope_size = 8;
9970            let bytes_len = max_ordinal as usize * envelope_size;
9971            #[allow(unused_variables)]
9972            let offset = encoder.out_of_line_offset(bytes_len);
9973            let mut _prev_end_offset: usize = 0;
9974            if 1 > max_ordinal {
9975                return Ok(());
9976            }
9977
9978            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9979            // are envelope_size bytes.
9980            let cur_offset: usize = (1 - 1) * envelope_size;
9981
9982            // Zero reserved fields.
9983            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9984
9985            // Safety:
9986            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9987            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9988            //   envelope_size bytes, there is always sufficient room.
9989            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 4095>, D>(
9990                self.data.as_ref().map(
9991                    <fidl::encoding::Vector<u8, 4095> as fidl::encoding::ValueTypeMarker>::borrow,
9992                ),
9993                encoder,
9994                offset + cur_offset,
9995                depth,
9996            )?;
9997
9998            _prev_end_offset = cur_offset + envelope_size;
9999
10000            Ok(())
10001        }
10002    }
10003
10004    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10005        for IsochronousStreamWriteRequest
10006    {
10007        #[inline(always)]
10008        fn new_empty() -> Self {
10009            Self::default()
10010        }
10011
10012        unsafe fn decode(
10013            &mut self,
10014            decoder: &mut fidl::encoding::Decoder<'_, D>,
10015            offset: usize,
10016            mut depth: fidl::encoding::Depth,
10017        ) -> fidl::Result<()> {
10018            decoder.debug_check_bounds::<Self>(offset);
10019            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10020                None => return Err(fidl::Error::NotNullable),
10021                Some(len) => len,
10022            };
10023            // Calling decoder.out_of_line_offset(0) is not allowed.
10024            if len == 0 {
10025                return Ok(());
10026            };
10027            depth.increment()?;
10028            let envelope_size = 8;
10029            let bytes_len = len * envelope_size;
10030            let offset = decoder.out_of_line_offset(bytes_len)?;
10031            // Decode the envelope for each type.
10032            let mut _next_ordinal_to_read = 0;
10033            let mut next_offset = offset;
10034            let end_offset = offset + bytes_len;
10035            _next_ordinal_to_read += 1;
10036            if next_offset >= end_offset {
10037                return Ok(());
10038            }
10039
10040            // Decode unknown envelopes for gaps in ordinals.
10041            while _next_ordinal_to_read < 1 {
10042                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10043                _next_ordinal_to_read += 1;
10044                next_offset += envelope_size;
10045            }
10046
10047            let next_out_of_line = decoder.next_out_of_line();
10048            let handles_before = decoder.remaining_handles();
10049            if let Some((inlined, num_bytes, num_handles)) =
10050                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10051            {
10052                let member_inline_size =
10053                    <fidl::encoding::Vector<u8, 4095> as fidl::encoding::TypeMarker>::inline_size(
10054                        decoder.context,
10055                    );
10056                if inlined != (member_inline_size <= 4) {
10057                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10058                }
10059                let inner_offset;
10060                let mut inner_depth = depth.clone();
10061                if inlined {
10062                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10063                    inner_offset = next_offset;
10064                } else {
10065                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10066                    inner_depth.increment()?;
10067                }
10068                let val_ref = self
10069                    .data
10070                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 4095>, D));
10071                fidl::decode!(fidl::encoding::Vector<u8, 4095>, D, val_ref, decoder, inner_offset, inner_depth)?;
10072                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10073                {
10074                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10075                }
10076                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10077                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10078                }
10079            }
10080
10081            next_offset += envelope_size;
10082
10083            // Decode the remaining unknown envelopes.
10084            while next_offset < end_offset {
10085                _next_ordinal_to_read += 1;
10086                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10087                next_offset += envelope_size;
10088            }
10089
10090            Ok(())
10091        }
10092    }
10093
10094    impl IsochronousStreamReadResponse {
10095        #[inline(always)]
10096        fn max_ordinal_present(&self) -> u64 {
10097            if let Some(_) = self.timestamp {
10098                return 4;
10099            }
10100            if let Some(_) = self.status_flag {
10101                return 3;
10102            }
10103            if let Some(_) = self.sequence_number {
10104                return 2;
10105            }
10106            if let Some(_) = self.data {
10107                return 1;
10108            }
10109            0
10110        }
10111    }
10112
10113    impl fidl::encoding::ValueTypeMarker for IsochronousStreamReadResponse {
10114        type Borrowed<'a> = &'a Self;
10115        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10116            value
10117        }
10118    }
10119
10120    unsafe impl fidl::encoding::TypeMarker for IsochronousStreamReadResponse {
10121        type Owned = Self;
10122
10123        #[inline(always)]
10124        fn inline_align(_context: fidl::encoding::Context) -> usize {
10125            8
10126        }
10127
10128        #[inline(always)]
10129        fn inline_size(_context: fidl::encoding::Context) -> usize {
10130            16
10131        }
10132    }
10133
10134    unsafe impl<D: fidl::encoding::ResourceDialect>
10135        fidl::encoding::Encode<IsochronousStreamReadResponse, D>
10136        for &IsochronousStreamReadResponse
10137    {
10138        unsafe fn encode(
10139            self,
10140            encoder: &mut fidl::encoding::Encoder<'_, D>,
10141            offset: usize,
10142            mut depth: fidl::encoding::Depth,
10143        ) -> fidl::Result<()> {
10144            encoder.debug_check_bounds::<IsochronousStreamReadResponse>(offset);
10145            // Vector header
10146            let max_ordinal: u64 = self.max_ordinal_present();
10147            encoder.write_num(max_ordinal, offset);
10148            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10149            // Calling encoder.out_of_line_offset(0) is not allowed.
10150            if max_ordinal == 0 {
10151                return Ok(());
10152            }
10153            depth.increment()?;
10154            let envelope_size = 8;
10155            let bytes_len = max_ordinal as usize * envelope_size;
10156            #[allow(unused_variables)]
10157            let offset = encoder.out_of_line_offset(bytes_len);
10158            let mut _prev_end_offset: usize = 0;
10159            if 1 > max_ordinal {
10160                return Ok(());
10161            }
10162
10163            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10164            // are envelope_size bytes.
10165            let cur_offset: usize = (1 - 1) * envelope_size;
10166
10167            // Zero reserved fields.
10168            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10169
10170            // Safety:
10171            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10172            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10173            //   envelope_size bytes, there is always sufficient room.
10174            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
10175            self.data.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
10176            encoder, offset + cur_offset, depth
10177        )?;
10178
10179            _prev_end_offset = cur_offset + envelope_size;
10180            if 2 > max_ordinal {
10181                return Ok(());
10182            }
10183
10184            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10185            // are envelope_size bytes.
10186            let cur_offset: usize = (2 - 1) * envelope_size;
10187
10188            // Zero reserved fields.
10189            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10190
10191            // Safety:
10192            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10193            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10194            //   envelope_size bytes, there is always sufficient room.
10195            fidl::encoding::encode_in_envelope_optional::<u16, D>(
10196                self.sequence_number.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
10197                encoder,
10198                offset + cur_offset,
10199                depth,
10200            )?;
10201
10202            _prev_end_offset = cur_offset + envelope_size;
10203            if 3 > max_ordinal {
10204                return Ok(());
10205            }
10206
10207            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10208            // are envelope_size bytes.
10209            let cur_offset: usize = (3 - 1) * envelope_size;
10210
10211            // Zero reserved fields.
10212            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10213
10214            // Safety:
10215            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10216            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10217            //   envelope_size bytes, there is always sufficient room.
10218            fidl::encoding::encode_in_envelope_optional::<IsoPacketStatusFlag, D>(
10219                self.status_flag
10220                    .as_ref()
10221                    .map(<IsoPacketStatusFlag as fidl::encoding::ValueTypeMarker>::borrow),
10222                encoder,
10223                offset + cur_offset,
10224                depth,
10225            )?;
10226
10227            _prev_end_offset = cur_offset + envelope_size;
10228            if 4 > max_ordinal {
10229                return Ok(());
10230            }
10231
10232            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10233            // are envelope_size bytes.
10234            let cur_offset: usize = (4 - 1) * envelope_size;
10235
10236            // Zero reserved fields.
10237            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10238
10239            // Safety:
10240            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10241            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10242            //   envelope_size bytes, there is always sufficient room.
10243            fidl::encoding::encode_in_envelope_optional::<i64, D>(
10244                self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
10245                encoder,
10246                offset + cur_offset,
10247                depth,
10248            )?;
10249
10250            _prev_end_offset = cur_offset + envelope_size;
10251
10252            Ok(())
10253        }
10254    }
10255
10256    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10257        for IsochronousStreamReadResponse
10258    {
10259        #[inline(always)]
10260        fn new_empty() -> Self {
10261            Self::default()
10262        }
10263
10264        unsafe fn decode(
10265            &mut self,
10266            decoder: &mut fidl::encoding::Decoder<'_, D>,
10267            offset: usize,
10268            mut depth: fidl::encoding::Depth,
10269        ) -> fidl::Result<()> {
10270            decoder.debug_check_bounds::<Self>(offset);
10271            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10272                None => return Err(fidl::Error::NotNullable),
10273                Some(len) => len,
10274            };
10275            // Calling decoder.out_of_line_offset(0) is not allowed.
10276            if len == 0 {
10277                return Ok(());
10278            };
10279            depth.increment()?;
10280            let envelope_size = 8;
10281            let bytes_len = len * envelope_size;
10282            let offset = decoder.out_of_line_offset(bytes_len)?;
10283            // Decode the envelope for each type.
10284            let mut _next_ordinal_to_read = 0;
10285            let mut next_offset = offset;
10286            let end_offset = offset + bytes_len;
10287            _next_ordinal_to_read += 1;
10288            if next_offset >= end_offset {
10289                return Ok(());
10290            }
10291
10292            // Decode unknown envelopes for gaps in ordinals.
10293            while _next_ordinal_to_read < 1 {
10294                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10295                _next_ordinal_to_read += 1;
10296                next_offset += envelope_size;
10297            }
10298
10299            let next_out_of_line = decoder.next_out_of_line();
10300            let handles_before = decoder.remaining_handles();
10301            if let Some((inlined, num_bytes, num_handles)) =
10302                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10303            {
10304                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10305                if inlined != (member_inline_size <= 4) {
10306                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10307                }
10308                let inner_offset;
10309                let mut inner_depth = depth.clone();
10310                if inlined {
10311                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10312                    inner_offset = next_offset;
10313                } else {
10314                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10315                    inner_depth.increment()?;
10316                }
10317                let val_ref = self.data.get_or_insert_with(|| {
10318                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
10319                });
10320                fidl::decode!(
10321                    fidl::encoding::UnboundedVector<u8>,
10322                    D,
10323                    val_ref,
10324                    decoder,
10325                    inner_offset,
10326                    inner_depth
10327                )?;
10328                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10329                {
10330                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10331                }
10332                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10333                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10334                }
10335            }
10336
10337            next_offset += envelope_size;
10338            _next_ordinal_to_read += 1;
10339            if next_offset >= end_offset {
10340                return Ok(());
10341            }
10342
10343            // Decode unknown envelopes for gaps in ordinals.
10344            while _next_ordinal_to_read < 2 {
10345                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10346                _next_ordinal_to_read += 1;
10347                next_offset += envelope_size;
10348            }
10349
10350            let next_out_of_line = decoder.next_out_of_line();
10351            let handles_before = decoder.remaining_handles();
10352            if let Some((inlined, num_bytes, num_handles)) =
10353                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10354            {
10355                let member_inline_size =
10356                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10357                if inlined != (member_inline_size <= 4) {
10358                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10359                }
10360                let inner_offset;
10361                let mut inner_depth = depth.clone();
10362                if inlined {
10363                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10364                    inner_offset = next_offset;
10365                } else {
10366                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10367                    inner_depth.increment()?;
10368                }
10369                let val_ref = self.sequence_number.get_or_insert_with(|| fidl::new_empty!(u16, D));
10370                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
10371                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10372                {
10373                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10374                }
10375                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10376                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10377                }
10378            }
10379
10380            next_offset += envelope_size;
10381            _next_ordinal_to_read += 1;
10382            if next_offset >= end_offset {
10383                return Ok(());
10384            }
10385
10386            // Decode unknown envelopes for gaps in ordinals.
10387            while _next_ordinal_to_read < 3 {
10388                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10389                _next_ordinal_to_read += 1;
10390                next_offset += envelope_size;
10391            }
10392
10393            let next_out_of_line = decoder.next_out_of_line();
10394            let handles_before = decoder.remaining_handles();
10395            if let Some((inlined, num_bytes, num_handles)) =
10396                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10397            {
10398                let member_inline_size =
10399                    <IsoPacketStatusFlag as fidl::encoding::TypeMarker>::inline_size(
10400                        decoder.context,
10401                    );
10402                if inlined != (member_inline_size <= 4) {
10403                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10404                }
10405                let inner_offset;
10406                let mut inner_depth = depth.clone();
10407                if inlined {
10408                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10409                    inner_offset = next_offset;
10410                } else {
10411                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10412                    inner_depth.increment()?;
10413                }
10414                let val_ref = self
10415                    .status_flag
10416                    .get_or_insert_with(|| fidl::new_empty!(IsoPacketStatusFlag, D));
10417                fidl::decode!(IsoPacketStatusFlag, D, val_ref, decoder, inner_offset, inner_depth)?;
10418                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10419                {
10420                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10421                }
10422                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10423                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10424                }
10425            }
10426
10427            next_offset += envelope_size;
10428            _next_ordinal_to_read += 1;
10429            if next_offset >= end_offset {
10430                return Ok(());
10431            }
10432
10433            // Decode unknown envelopes for gaps in ordinals.
10434            while _next_ordinal_to_read < 4 {
10435                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10436                _next_ordinal_to_read += 1;
10437                next_offset += envelope_size;
10438            }
10439
10440            let next_out_of_line = decoder.next_out_of_line();
10441            let handles_before = decoder.remaining_handles();
10442            if let Some((inlined, num_bytes, num_handles)) =
10443                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10444            {
10445                let member_inline_size =
10446                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10447                if inlined != (member_inline_size <= 4) {
10448                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10449                }
10450                let inner_offset;
10451                let mut inner_depth = depth.clone();
10452                if inlined {
10453                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10454                    inner_offset = next_offset;
10455                } else {
10456                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10457                    inner_depth.increment()?;
10458                }
10459                let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
10460                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
10461                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10462                {
10463                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10464                }
10465                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10466                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10467                }
10468            }
10469
10470            next_offset += envelope_size;
10471
10472            // Decode the remaining unknown envelopes.
10473            while next_offset < end_offset {
10474                _next_ordinal_to_read += 1;
10475                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10476                next_offset += envelope_size;
10477            }
10478
10479            Ok(())
10480        }
10481    }
10482
10483    impl Legacy {
10484        #[inline(always)]
10485        fn max_ordinal_present(&self) -> u64 {
10486            0
10487        }
10488    }
10489
10490    impl fidl::encoding::ValueTypeMarker for Legacy {
10491        type Borrowed<'a> = &'a Self;
10492        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10493            value
10494        }
10495    }
10496
10497    unsafe impl fidl::encoding::TypeMarker for Legacy {
10498        type Owned = Self;
10499
10500        #[inline(always)]
10501        fn inline_align(_context: fidl::encoding::Context) -> usize {
10502            8
10503        }
10504
10505        #[inline(always)]
10506        fn inline_size(_context: fidl::encoding::Context) -> usize {
10507            16
10508        }
10509    }
10510
10511    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Legacy, D> for &Legacy {
10512        unsafe fn encode(
10513            self,
10514            encoder: &mut fidl::encoding::Encoder<'_, D>,
10515            offset: usize,
10516            mut depth: fidl::encoding::Depth,
10517        ) -> fidl::Result<()> {
10518            encoder.debug_check_bounds::<Legacy>(offset);
10519            // Vector header
10520            let max_ordinal: u64 = self.max_ordinal_present();
10521            encoder.write_num(max_ordinal, offset);
10522            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10523            // Calling encoder.out_of_line_offset(0) is not allowed.
10524            if max_ordinal == 0 {
10525                return Ok(());
10526            }
10527            depth.increment()?;
10528            let envelope_size = 8;
10529            let bytes_len = max_ordinal as usize * envelope_size;
10530            #[allow(unused_variables)]
10531            let offset = encoder.out_of_line_offset(bytes_len);
10532            let mut _prev_end_offset: usize = 0;
10533
10534            Ok(())
10535        }
10536    }
10537
10538    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Legacy {
10539        #[inline(always)]
10540        fn new_empty() -> Self {
10541            Self::default()
10542        }
10543
10544        unsafe fn decode(
10545            &mut self,
10546            decoder: &mut fidl::encoding::Decoder<'_, D>,
10547            offset: usize,
10548            mut depth: fidl::encoding::Depth,
10549        ) -> fidl::Result<()> {
10550            decoder.debug_check_bounds::<Self>(offset);
10551            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10552                None => return Err(fidl::Error::NotNullable),
10553                Some(len) => len,
10554            };
10555            // Calling decoder.out_of_line_offset(0) is not allowed.
10556            if len == 0 {
10557                return Ok(());
10558            };
10559            depth.increment()?;
10560            let envelope_size = 8;
10561            let bytes_len = len * envelope_size;
10562            let offset = decoder.out_of_line_offset(bytes_len)?;
10563            // Decode the envelope for each type.
10564            let mut _next_ordinal_to_read = 0;
10565            let mut next_offset = offset;
10566            let end_offset = offset + bytes_len;
10567
10568            // Decode the remaining unknown envelopes.
10569            while next_offset < end_offset {
10570                _next_ordinal_to_read += 1;
10571                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10572                next_offset += envelope_size;
10573            }
10574
10575            Ok(())
10576        }
10577    }
10578
10579    impl Peer {
10580        #[inline(always)]
10581        fn max_ordinal_present(&self) -> u64 {
10582            if let Some(_) = self.periodic_advertising_interval {
10583                return 10;
10584            }
10585            if let Some(_) = self.advertising_sid {
10586                return 9;
10587            }
10588            if let Some(_) = self.last_updated {
10589                return 8;
10590            }
10591            if let Some(_) = self.bonded {
10592                return 7;
10593            }
10594            if let Some(_) = self.data {
10595                return 6;
10596            }
10597            if let Some(_) = self.name {
10598                return 5;
10599            }
10600            if let Some(_) = self.advertising_data {
10601                return 4;
10602            }
10603            if let Some(_) = self.rssi {
10604                return 3;
10605            }
10606            if let Some(_) = self.connectable {
10607                return 2;
10608            }
10609            if let Some(_) = self.id {
10610                return 1;
10611            }
10612            0
10613        }
10614    }
10615
10616    impl fidl::encoding::ValueTypeMarker for Peer {
10617        type Borrowed<'a> = &'a Self;
10618        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10619            value
10620        }
10621    }
10622
10623    unsafe impl fidl::encoding::TypeMarker for Peer {
10624        type Owned = Self;
10625
10626        #[inline(always)]
10627        fn inline_align(_context: fidl::encoding::Context) -> usize {
10628            8
10629        }
10630
10631        #[inline(always)]
10632        fn inline_size(_context: fidl::encoding::Context) -> usize {
10633            16
10634        }
10635    }
10636
10637    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Peer, D> for &Peer {
10638        unsafe fn encode(
10639            self,
10640            encoder: &mut fidl::encoding::Encoder<'_, D>,
10641            offset: usize,
10642            mut depth: fidl::encoding::Depth,
10643        ) -> fidl::Result<()> {
10644            encoder.debug_check_bounds::<Peer>(offset);
10645            // Vector header
10646            let max_ordinal: u64 = self.max_ordinal_present();
10647            encoder.write_num(max_ordinal, offset);
10648            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10649            // Calling encoder.out_of_line_offset(0) is not allowed.
10650            if max_ordinal == 0 {
10651                return Ok(());
10652            }
10653            depth.increment()?;
10654            let envelope_size = 8;
10655            let bytes_len = max_ordinal as usize * envelope_size;
10656            #[allow(unused_variables)]
10657            let offset = encoder.out_of_line_offset(bytes_len);
10658            let mut _prev_end_offset: usize = 0;
10659            if 1 > max_ordinal {
10660                return Ok(());
10661            }
10662
10663            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10664            // are envelope_size bytes.
10665            let cur_offset: usize = (1 - 1) * envelope_size;
10666
10667            // Zero reserved fields.
10668            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10669
10670            // Safety:
10671            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10672            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10673            //   envelope_size bytes, there is always sufficient room.
10674            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::PeerId, D>(
10675            self.id.as_ref().map(<fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow),
10676            encoder, offset + cur_offset, depth
10677        )?;
10678
10679            _prev_end_offset = cur_offset + envelope_size;
10680            if 2 > max_ordinal {
10681                return Ok(());
10682            }
10683
10684            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10685            // are envelope_size bytes.
10686            let cur_offset: usize = (2 - 1) * envelope_size;
10687
10688            // Zero reserved fields.
10689            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10690
10691            // Safety:
10692            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10693            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10694            //   envelope_size bytes, there is always sufficient room.
10695            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10696                self.connectable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10697                encoder,
10698                offset + cur_offset,
10699                depth,
10700            )?;
10701
10702            _prev_end_offset = cur_offset + envelope_size;
10703            if 3 > max_ordinal {
10704                return Ok(());
10705            }
10706
10707            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10708            // are envelope_size bytes.
10709            let cur_offset: usize = (3 - 1) * envelope_size;
10710
10711            // Zero reserved fields.
10712            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10713
10714            // Safety:
10715            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10716            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10717            //   envelope_size bytes, there is always sufficient room.
10718            fidl::encoding::encode_in_envelope_optional::<i8, D>(
10719                self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
10720                encoder,
10721                offset + cur_offset,
10722                depth,
10723            )?;
10724
10725            _prev_end_offset = cur_offset + envelope_size;
10726            if 4 > max_ordinal {
10727                return Ok(());
10728            }
10729
10730            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10731            // are envelope_size bytes.
10732            let cur_offset: usize = (4 - 1) * envelope_size;
10733
10734            // Zero reserved fields.
10735            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10736
10737            // Safety:
10738            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10739            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10740            //   envelope_size bytes, there is always sufficient room.
10741            fidl::encoding::encode_in_envelope_optional::<AdvertisingData, D>(
10742                self.advertising_data
10743                    .as_ref()
10744                    .map(<AdvertisingData as fidl::encoding::ValueTypeMarker>::borrow),
10745                encoder,
10746                offset + cur_offset,
10747                depth,
10748            )?;
10749
10750            _prev_end_offset = cur_offset + envelope_size;
10751            if 5 > max_ordinal {
10752                return Ok(());
10753            }
10754
10755            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10756            // are envelope_size bytes.
10757            let cur_offset: usize = (5 - 1) * envelope_size;
10758
10759            // Zero reserved fields.
10760            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10761
10762            // Safety:
10763            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10764            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10765            //   envelope_size bytes, there is always sufficient room.
10766            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<248>, D>(
10767                self.name.as_ref().map(
10768                    <fidl::encoding::BoundedString<248> as fidl::encoding::ValueTypeMarker>::borrow,
10769                ),
10770                encoder,
10771                offset + cur_offset,
10772                depth,
10773            )?;
10774
10775            _prev_end_offset = cur_offset + envelope_size;
10776            if 6 > max_ordinal {
10777                return Ok(());
10778            }
10779
10780            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10781            // are envelope_size bytes.
10782            let cur_offset: usize = (6 - 1) * envelope_size;
10783
10784            // Zero reserved fields.
10785            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10786
10787            // Safety:
10788            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10789            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10790            //   envelope_size bytes, there is always sufficient room.
10791            fidl::encoding::encode_in_envelope_optional::<ScanData, D>(
10792                self.data.as_ref().map(<ScanData as fidl::encoding::ValueTypeMarker>::borrow),
10793                encoder,
10794                offset + cur_offset,
10795                depth,
10796            )?;
10797
10798            _prev_end_offset = cur_offset + envelope_size;
10799            if 7 > max_ordinal {
10800                return Ok(());
10801            }
10802
10803            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10804            // are envelope_size bytes.
10805            let cur_offset: usize = (7 - 1) * envelope_size;
10806
10807            // Zero reserved fields.
10808            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10809
10810            // Safety:
10811            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10812            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10813            //   envelope_size bytes, there is always sufficient room.
10814            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10815                self.bonded.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10816                encoder,
10817                offset + cur_offset,
10818                depth,
10819            )?;
10820
10821            _prev_end_offset = cur_offset + envelope_size;
10822            if 8 > max_ordinal {
10823                return Ok(());
10824            }
10825
10826            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10827            // are envelope_size bytes.
10828            let cur_offset: usize = (8 - 1) * envelope_size;
10829
10830            // Zero reserved fields.
10831            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10832
10833            // Safety:
10834            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10835            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10836            //   envelope_size bytes, there is always sufficient room.
10837            fidl::encoding::encode_in_envelope_optional::<i64, D>(
10838                self.last_updated.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
10839                encoder,
10840                offset + cur_offset,
10841                depth,
10842            )?;
10843
10844            _prev_end_offset = cur_offset + envelope_size;
10845            if 9 > max_ordinal {
10846                return Ok(());
10847            }
10848
10849            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10850            // are envelope_size bytes.
10851            let cur_offset: usize = (9 - 1) * envelope_size;
10852
10853            // Zero reserved fields.
10854            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10855
10856            // Safety:
10857            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10858            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10859            //   envelope_size bytes, there is always sufficient room.
10860            fidl::encoding::encode_in_envelope_optional::<u8, D>(
10861                self.advertising_sid.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
10862                encoder,
10863                offset + cur_offset,
10864                depth,
10865            )?;
10866
10867            _prev_end_offset = cur_offset + envelope_size;
10868            if 10 > max_ordinal {
10869                return Ok(());
10870            }
10871
10872            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10873            // are envelope_size bytes.
10874            let cur_offset: usize = (10 - 1) * envelope_size;
10875
10876            // Zero reserved fields.
10877            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10878
10879            // Safety:
10880            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10881            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10882            //   envelope_size bytes, there is always sufficient room.
10883            fidl::encoding::encode_in_envelope_optional::<u16, D>(
10884                self.periodic_advertising_interval
10885                    .as_ref()
10886                    .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
10887                encoder,
10888                offset + cur_offset,
10889                depth,
10890            )?;
10891
10892            _prev_end_offset = cur_offset + envelope_size;
10893
10894            Ok(())
10895        }
10896    }
10897
10898    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Peer {
10899        #[inline(always)]
10900        fn new_empty() -> Self {
10901            Self::default()
10902        }
10903
10904        unsafe fn decode(
10905            &mut self,
10906            decoder: &mut fidl::encoding::Decoder<'_, D>,
10907            offset: usize,
10908            mut depth: fidl::encoding::Depth,
10909        ) -> fidl::Result<()> {
10910            decoder.debug_check_bounds::<Self>(offset);
10911            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10912                None => return Err(fidl::Error::NotNullable),
10913                Some(len) => len,
10914            };
10915            // Calling decoder.out_of_line_offset(0) is not allowed.
10916            if len == 0 {
10917                return Ok(());
10918            };
10919            depth.increment()?;
10920            let envelope_size = 8;
10921            let bytes_len = len * envelope_size;
10922            let offset = decoder.out_of_line_offset(bytes_len)?;
10923            // Decode the envelope for each type.
10924            let mut _next_ordinal_to_read = 0;
10925            let mut next_offset = offset;
10926            let end_offset = offset + bytes_len;
10927            _next_ordinal_to_read += 1;
10928            if next_offset >= end_offset {
10929                return Ok(());
10930            }
10931
10932            // Decode unknown envelopes for gaps in ordinals.
10933            while _next_ordinal_to_read < 1 {
10934                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10935                _next_ordinal_to_read += 1;
10936                next_offset += envelope_size;
10937            }
10938
10939            let next_out_of_line = decoder.next_out_of_line();
10940            let handles_before = decoder.remaining_handles();
10941            if let Some((inlined, num_bytes, num_handles)) =
10942                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10943            {
10944                let member_inline_size = <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10945                if inlined != (member_inline_size <= 4) {
10946                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10947                }
10948                let inner_offset;
10949                let mut inner_depth = depth.clone();
10950                if inlined {
10951                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10952                    inner_offset = next_offset;
10953                } else {
10954                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10955                    inner_depth.increment()?;
10956                }
10957                let val_ref = self.id.get_or_insert_with(|| {
10958                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D)
10959                });
10960                fidl::decode!(
10961                    fidl_fuchsia_bluetooth__common::PeerId,
10962                    D,
10963                    val_ref,
10964                    decoder,
10965                    inner_offset,
10966                    inner_depth
10967                )?;
10968                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10969                {
10970                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10971                }
10972                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10973                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10974                }
10975            }
10976
10977            next_offset += envelope_size;
10978            _next_ordinal_to_read += 1;
10979            if next_offset >= end_offset {
10980                return Ok(());
10981            }
10982
10983            // Decode unknown envelopes for gaps in ordinals.
10984            while _next_ordinal_to_read < 2 {
10985                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10986                _next_ordinal_to_read += 1;
10987                next_offset += envelope_size;
10988            }
10989
10990            let next_out_of_line = decoder.next_out_of_line();
10991            let handles_before = decoder.remaining_handles();
10992            if let Some((inlined, num_bytes, num_handles)) =
10993                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10994            {
10995                let member_inline_size =
10996                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10997                if inlined != (member_inline_size <= 4) {
10998                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10999                }
11000                let inner_offset;
11001                let mut inner_depth = depth.clone();
11002                if inlined {
11003                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11004                    inner_offset = next_offset;
11005                } else {
11006                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11007                    inner_depth.increment()?;
11008                }
11009                let val_ref = self.connectable.get_or_insert_with(|| fidl::new_empty!(bool, D));
11010                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
11011                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11012                {
11013                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11014                }
11015                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11016                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11017                }
11018            }
11019
11020            next_offset += envelope_size;
11021            _next_ordinal_to_read += 1;
11022            if next_offset >= end_offset {
11023                return Ok(());
11024            }
11025
11026            // Decode unknown envelopes for gaps in ordinals.
11027            while _next_ordinal_to_read < 3 {
11028                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11029                _next_ordinal_to_read += 1;
11030                next_offset += envelope_size;
11031            }
11032
11033            let next_out_of_line = decoder.next_out_of_line();
11034            let handles_before = decoder.remaining_handles();
11035            if let Some((inlined, num_bytes, num_handles)) =
11036                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11037            {
11038                let member_inline_size =
11039                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11040                if inlined != (member_inline_size <= 4) {
11041                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11042                }
11043                let inner_offset;
11044                let mut inner_depth = depth.clone();
11045                if inlined {
11046                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11047                    inner_offset = next_offset;
11048                } else {
11049                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11050                    inner_depth.increment()?;
11051                }
11052                let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
11053                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
11054                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11055                {
11056                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11057                }
11058                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11059                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11060                }
11061            }
11062
11063            next_offset += envelope_size;
11064            _next_ordinal_to_read += 1;
11065            if next_offset >= end_offset {
11066                return Ok(());
11067            }
11068
11069            // Decode unknown envelopes for gaps in ordinals.
11070            while _next_ordinal_to_read < 4 {
11071                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11072                _next_ordinal_to_read += 1;
11073                next_offset += envelope_size;
11074            }
11075
11076            let next_out_of_line = decoder.next_out_of_line();
11077            let handles_before = decoder.remaining_handles();
11078            if let Some((inlined, num_bytes, num_handles)) =
11079                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11080            {
11081                let member_inline_size =
11082                    <AdvertisingData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11083                if inlined != (member_inline_size <= 4) {
11084                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11085                }
11086                let inner_offset;
11087                let mut inner_depth = depth.clone();
11088                if inlined {
11089                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11090                    inner_offset = next_offset;
11091                } else {
11092                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11093                    inner_depth.increment()?;
11094                }
11095                let val_ref = self
11096                    .advertising_data
11097                    .get_or_insert_with(|| fidl::new_empty!(AdvertisingData, D));
11098                fidl::decode!(AdvertisingData, D, val_ref, decoder, inner_offset, inner_depth)?;
11099                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11100                {
11101                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11102                }
11103                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11104                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11105                }
11106            }
11107
11108            next_offset += envelope_size;
11109            _next_ordinal_to_read += 1;
11110            if next_offset >= end_offset {
11111                return Ok(());
11112            }
11113
11114            // Decode unknown envelopes for gaps in ordinals.
11115            while _next_ordinal_to_read < 5 {
11116                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11117                _next_ordinal_to_read += 1;
11118                next_offset += envelope_size;
11119            }
11120
11121            let next_out_of_line = decoder.next_out_of_line();
11122            let handles_before = decoder.remaining_handles();
11123            if let Some((inlined, num_bytes, num_handles)) =
11124                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11125            {
11126                let member_inline_size =
11127                    <fidl::encoding::BoundedString<248> as fidl::encoding::TypeMarker>::inline_size(
11128                        decoder.context,
11129                    );
11130                if inlined != (member_inline_size <= 4) {
11131                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11132                }
11133                let inner_offset;
11134                let mut inner_depth = depth.clone();
11135                if inlined {
11136                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11137                    inner_offset = next_offset;
11138                } else {
11139                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11140                    inner_depth.increment()?;
11141                }
11142                let val_ref = self
11143                    .name
11144                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<248>, D));
11145                fidl::decode!(
11146                    fidl::encoding::BoundedString<248>,
11147                    D,
11148                    val_ref,
11149                    decoder,
11150                    inner_offset,
11151                    inner_depth
11152                )?;
11153                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11154                {
11155                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11156                }
11157                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11158                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11159                }
11160            }
11161
11162            next_offset += envelope_size;
11163            _next_ordinal_to_read += 1;
11164            if next_offset >= end_offset {
11165                return Ok(());
11166            }
11167
11168            // Decode unknown envelopes for gaps in ordinals.
11169            while _next_ordinal_to_read < 6 {
11170                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11171                _next_ordinal_to_read += 1;
11172                next_offset += envelope_size;
11173            }
11174
11175            let next_out_of_line = decoder.next_out_of_line();
11176            let handles_before = decoder.remaining_handles();
11177            if let Some((inlined, num_bytes, num_handles)) =
11178                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11179            {
11180                let member_inline_size =
11181                    <ScanData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11182                if inlined != (member_inline_size <= 4) {
11183                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11184                }
11185                let inner_offset;
11186                let mut inner_depth = depth.clone();
11187                if inlined {
11188                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11189                    inner_offset = next_offset;
11190                } else {
11191                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11192                    inner_depth.increment()?;
11193                }
11194                let val_ref = self.data.get_or_insert_with(|| fidl::new_empty!(ScanData, D));
11195                fidl::decode!(ScanData, D, val_ref, decoder, inner_offset, inner_depth)?;
11196                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11197                {
11198                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11199                }
11200                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11201                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11202                }
11203            }
11204
11205            next_offset += envelope_size;
11206            _next_ordinal_to_read += 1;
11207            if next_offset >= end_offset {
11208                return Ok(());
11209            }
11210
11211            // Decode unknown envelopes for gaps in ordinals.
11212            while _next_ordinal_to_read < 7 {
11213                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11214                _next_ordinal_to_read += 1;
11215                next_offset += envelope_size;
11216            }
11217
11218            let next_out_of_line = decoder.next_out_of_line();
11219            let handles_before = decoder.remaining_handles();
11220            if let Some((inlined, num_bytes, num_handles)) =
11221                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11222            {
11223                let member_inline_size =
11224                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11225                if inlined != (member_inline_size <= 4) {
11226                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11227                }
11228                let inner_offset;
11229                let mut inner_depth = depth.clone();
11230                if inlined {
11231                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11232                    inner_offset = next_offset;
11233                } else {
11234                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11235                    inner_depth.increment()?;
11236                }
11237                let val_ref = self.bonded.get_or_insert_with(|| fidl::new_empty!(bool, D));
11238                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
11239                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11240                {
11241                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11242                }
11243                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11244                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11245                }
11246            }
11247
11248            next_offset += envelope_size;
11249            _next_ordinal_to_read += 1;
11250            if next_offset >= end_offset {
11251                return Ok(());
11252            }
11253
11254            // Decode unknown envelopes for gaps in ordinals.
11255            while _next_ordinal_to_read < 8 {
11256                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11257                _next_ordinal_to_read += 1;
11258                next_offset += envelope_size;
11259            }
11260
11261            let next_out_of_line = decoder.next_out_of_line();
11262            let handles_before = decoder.remaining_handles();
11263            if let Some((inlined, num_bytes, num_handles)) =
11264                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11265            {
11266                let member_inline_size =
11267                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11268                if inlined != (member_inline_size <= 4) {
11269                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11270                }
11271                let inner_offset;
11272                let mut inner_depth = depth.clone();
11273                if inlined {
11274                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11275                    inner_offset = next_offset;
11276                } else {
11277                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11278                    inner_depth.increment()?;
11279                }
11280                let val_ref = self.last_updated.get_or_insert_with(|| fidl::new_empty!(i64, D));
11281                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
11282                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11283                {
11284                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11285                }
11286                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11287                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11288                }
11289            }
11290
11291            next_offset += envelope_size;
11292            _next_ordinal_to_read += 1;
11293            if next_offset >= end_offset {
11294                return Ok(());
11295            }
11296
11297            // Decode unknown envelopes for gaps in ordinals.
11298            while _next_ordinal_to_read < 9 {
11299                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11300                _next_ordinal_to_read += 1;
11301                next_offset += envelope_size;
11302            }
11303
11304            let next_out_of_line = decoder.next_out_of_line();
11305            let handles_before = decoder.remaining_handles();
11306            if let Some((inlined, num_bytes, num_handles)) =
11307                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11308            {
11309                let member_inline_size =
11310                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11311                if inlined != (member_inline_size <= 4) {
11312                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11313                }
11314                let inner_offset;
11315                let mut inner_depth = depth.clone();
11316                if inlined {
11317                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11318                    inner_offset = next_offset;
11319                } else {
11320                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11321                    inner_depth.increment()?;
11322                }
11323                let val_ref = self.advertising_sid.get_or_insert_with(|| fidl::new_empty!(u8, D));
11324                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
11325                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11326                {
11327                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11328                }
11329                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11330                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11331                }
11332            }
11333
11334            next_offset += envelope_size;
11335            _next_ordinal_to_read += 1;
11336            if next_offset >= end_offset {
11337                return Ok(());
11338            }
11339
11340            // Decode unknown envelopes for gaps in ordinals.
11341            while _next_ordinal_to_read < 10 {
11342                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11343                _next_ordinal_to_read += 1;
11344                next_offset += envelope_size;
11345            }
11346
11347            let next_out_of_line = decoder.next_out_of_line();
11348            let handles_before = decoder.remaining_handles();
11349            if let Some((inlined, num_bytes, num_handles)) =
11350                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11351            {
11352                let member_inline_size =
11353                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11354                if inlined != (member_inline_size <= 4) {
11355                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11356                }
11357                let inner_offset;
11358                let mut inner_depth = depth.clone();
11359                if inlined {
11360                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11361                    inner_offset = next_offset;
11362                } else {
11363                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11364                    inner_depth.increment()?;
11365                }
11366                let val_ref = self
11367                    .periodic_advertising_interval
11368                    .get_or_insert_with(|| fidl::new_empty!(u16, D));
11369                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
11370                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11371                {
11372                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11373                }
11374                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11375                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11376                }
11377            }
11378
11379            next_offset += envelope_size;
11380
11381            // Decode the remaining unknown envelopes.
11382            while next_offset < end_offset {
11383                _next_ordinal_to_read += 1;
11384                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11385                next_offset += envelope_size;
11386            }
11387
11388            Ok(())
11389        }
11390    }
11391
11392    impl ScanData {
11393        #[inline(always)]
11394        fn max_ordinal_present(&self) -> u64 {
11395            if let Some(_) = self.timestamp {
11396                return 7;
11397            }
11398            if let Some(_) = self.uris {
11399                return 6;
11400            }
11401            if let Some(_) = self.manufacturer_data {
11402                return 5;
11403            }
11404            if let Some(_) = self.service_data {
11405                return 4;
11406            }
11407            if let Some(_) = self.service_uuids {
11408                return 3;
11409            }
11410            if let Some(_) = self.appearance {
11411                return 2;
11412            }
11413            if let Some(_) = self.tx_power {
11414                return 1;
11415            }
11416            0
11417        }
11418    }
11419
11420    impl fidl::encoding::ValueTypeMarker for ScanData {
11421        type Borrowed<'a> = &'a Self;
11422        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11423            value
11424        }
11425    }
11426
11427    unsafe impl fidl::encoding::TypeMarker for ScanData {
11428        type Owned = Self;
11429
11430        #[inline(always)]
11431        fn inline_align(_context: fidl::encoding::Context) -> usize {
11432            8
11433        }
11434
11435        #[inline(always)]
11436        fn inline_size(_context: fidl::encoding::Context) -> usize {
11437            16
11438        }
11439    }
11440
11441    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ScanData, D> for &ScanData {
11442        unsafe fn encode(
11443            self,
11444            encoder: &mut fidl::encoding::Encoder<'_, D>,
11445            offset: usize,
11446            mut depth: fidl::encoding::Depth,
11447        ) -> fidl::Result<()> {
11448            encoder.debug_check_bounds::<ScanData>(offset);
11449            // Vector header
11450            let max_ordinal: u64 = self.max_ordinal_present();
11451            encoder.write_num(max_ordinal, offset);
11452            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11453            // Calling encoder.out_of_line_offset(0) is not allowed.
11454            if max_ordinal == 0 {
11455                return Ok(());
11456            }
11457            depth.increment()?;
11458            let envelope_size = 8;
11459            let bytes_len = max_ordinal as usize * envelope_size;
11460            #[allow(unused_variables)]
11461            let offset = encoder.out_of_line_offset(bytes_len);
11462            let mut _prev_end_offset: usize = 0;
11463            if 1 > max_ordinal {
11464                return Ok(());
11465            }
11466
11467            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11468            // are envelope_size bytes.
11469            let cur_offset: usize = (1 - 1) * envelope_size;
11470
11471            // Zero reserved fields.
11472            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11473
11474            // Safety:
11475            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11476            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11477            //   envelope_size bytes, there is always sufficient room.
11478            fidl::encoding::encode_in_envelope_optional::<i8, D>(
11479                self.tx_power.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
11480                encoder,
11481                offset + cur_offset,
11482                depth,
11483            )?;
11484
11485            _prev_end_offset = cur_offset + envelope_size;
11486            if 2 > max_ordinal {
11487                return Ok(());
11488            }
11489
11490            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11491            // are envelope_size bytes.
11492            let cur_offset: usize = (2 - 1) * envelope_size;
11493
11494            // Zero reserved fields.
11495            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11496
11497            // Safety:
11498            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11499            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11500            //   envelope_size bytes, there is always sufficient room.
11501            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Appearance, D>(
11502            self.appearance.as_ref().map(<fidl_fuchsia_bluetooth__common::Appearance as fidl::encoding::ValueTypeMarker>::borrow),
11503            encoder, offset + cur_offset, depth
11504        )?;
11505
11506            _prev_end_offset = cur_offset + envelope_size;
11507            if 3 > max_ordinal {
11508                return Ok(());
11509            }
11510
11511            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11512            // are envelope_size bytes.
11513            let cur_offset: usize = (3 - 1) * envelope_size;
11514
11515            // Zero reserved fields.
11516            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11517
11518            // Safety:
11519            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11520            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11521            //   envelope_size bytes, there is always sufficient room.
11522            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>, D>(
11523            self.service_uuids.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid> as fidl::encoding::ValueTypeMarker>::borrow),
11524            encoder, offset + cur_offset, depth
11525        )?;
11526
11527            _prev_end_offset = cur_offset + envelope_size;
11528            if 4 > max_ordinal {
11529                return Ok(());
11530            }
11531
11532            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11533            // are envelope_size bytes.
11534            let cur_offset: usize = (4 - 1) * envelope_size;
11535
11536            // Zero reserved fields.
11537            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11538
11539            // Safety:
11540            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11541            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11542            //   envelope_size bytes, there is always sufficient room.
11543            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ServiceData>, D>(
11544            self.service_data.as_ref().map(<fidl::encoding::UnboundedVector<ServiceData> as fidl::encoding::ValueTypeMarker>::borrow),
11545            encoder, offset + cur_offset, depth
11546        )?;
11547
11548            _prev_end_offset = cur_offset + envelope_size;
11549            if 5 > max_ordinal {
11550                return Ok(());
11551            }
11552
11553            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11554            // are envelope_size bytes.
11555            let cur_offset: usize = (5 - 1) * envelope_size;
11556
11557            // Zero reserved fields.
11558            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11559
11560            // Safety:
11561            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11562            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11563            //   envelope_size bytes, there is always sufficient room.
11564            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ManufacturerData>, D>(
11565            self.manufacturer_data.as_ref().map(<fidl::encoding::UnboundedVector<ManufacturerData> as fidl::encoding::ValueTypeMarker>::borrow),
11566            encoder, offset + cur_offset, depth
11567        )?;
11568
11569            _prev_end_offset = cur_offset + envelope_size;
11570            if 6 > max_ordinal {
11571                return Ok(());
11572            }
11573
11574            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11575            // are envelope_size bytes.
11576            let cur_offset: usize = (6 - 1) * envelope_size;
11577
11578            // Zero reserved fields.
11579            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11580
11581            // Safety:
11582            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11583            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11584            //   envelope_size bytes, there is always sufficient room.
11585            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>, D>(
11586            self.uris.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>> as fidl::encoding::ValueTypeMarker>::borrow),
11587            encoder, offset + cur_offset, depth
11588        )?;
11589
11590            _prev_end_offset = cur_offset + envelope_size;
11591            if 7 > max_ordinal {
11592                return Ok(());
11593            }
11594
11595            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11596            // are envelope_size bytes.
11597            let cur_offset: usize = (7 - 1) * envelope_size;
11598
11599            // Zero reserved fields.
11600            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11601
11602            // Safety:
11603            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11604            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11605            //   envelope_size bytes, there is always sufficient room.
11606            fidl::encoding::encode_in_envelope_optional::<i64, D>(
11607                self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
11608                encoder,
11609                offset + cur_offset,
11610                depth,
11611            )?;
11612
11613            _prev_end_offset = cur_offset + envelope_size;
11614
11615            Ok(())
11616        }
11617    }
11618
11619    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanData {
11620        #[inline(always)]
11621        fn new_empty() -> Self {
11622            Self::default()
11623        }
11624
11625        unsafe fn decode(
11626            &mut self,
11627            decoder: &mut fidl::encoding::Decoder<'_, D>,
11628            offset: usize,
11629            mut depth: fidl::encoding::Depth,
11630        ) -> fidl::Result<()> {
11631            decoder.debug_check_bounds::<Self>(offset);
11632            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11633                None => return Err(fidl::Error::NotNullable),
11634                Some(len) => len,
11635            };
11636            // Calling decoder.out_of_line_offset(0) is not allowed.
11637            if len == 0 {
11638                return Ok(());
11639            };
11640            depth.increment()?;
11641            let envelope_size = 8;
11642            let bytes_len = len * envelope_size;
11643            let offset = decoder.out_of_line_offset(bytes_len)?;
11644            // Decode the envelope for each type.
11645            let mut _next_ordinal_to_read = 0;
11646            let mut next_offset = offset;
11647            let end_offset = offset + bytes_len;
11648            _next_ordinal_to_read += 1;
11649            if next_offset >= end_offset {
11650                return Ok(());
11651            }
11652
11653            // Decode unknown envelopes for gaps in ordinals.
11654            while _next_ordinal_to_read < 1 {
11655                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11656                _next_ordinal_to_read += 1;
11657                next_offset += envelope_size;
11658            }
11659
11660            let next_out_of_line = decoder.next_out_of_line();
11661            let handles_before = decoder.remaining_handles();
11662            if let Some((inlined, num_bytes, num_handles)) =
11663                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11664            {
11665                let member_inline_size =
11666                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11667                if inlined != (member_inline_size <= 4) {
11668                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11669                }
11670                let inner_offset;
11671                let mut inner_depth = depth.clone();
11672                if inlined {
11673                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11674                    inner_offset = next_offset;
11675                } else {
11676                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11677                    inner_depth.increment()?;
11678                }
11679                let val_ref = self.tx_power.get_or_insert_with(|| fidl::new_empty!(i8, D));
11680                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
11681                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11682                {
11683                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11684                }
11685                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11686                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11687                }
11688            }
11689
11690            next_offset += envelope_size;
11691            _next_ordinal_to_read += 1;
11692            if next_offset >= end_offset {
11693                return Ok(());
11694            }
11695
11696            // Decode unknown envelopes for gaps in ordinals.
11697            while _next_ordinal_to_read < 2 {
11698                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11699                _next_ordinal_to_read += 1;
11700                next_offset += envelope_size;
11701            }
11702
11703            let next_out_of_line = decoder.next_out_of_line();
11704            let handles_before = decoder.remaining_handles();
11705            if let Some((inlined, num_bytes, num_handles)) =
11706                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11707            {
11708                let member_inline_size = <fidl_fuchsia_bluetooth__common::Appearance as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11709                if inlined != (member_inline_size <= 4) {
11710                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11711                }
11712                let inner_offset;
11713                let mut inner_depth = depth.clone();
11714                if inlined {
11715                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11716                    inner_offset = next_offset;
11717                } else {
11718                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11719                    inner_depth.increment()?;
11720                }
11721                let val_ref = self.appearance.get_or_insert_with(|| {
11722                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::Appearance, D)
11723                });
11724                fidl::decode!(
11725                    fidl_fuchsia_bluetooth__common::Appearance,
11726                    D,
11727                    val_ref,
11728                    decoder,
11729                    inner_offset,
11730                    inner_depth
11731                )?;
11732                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11733                {
11734                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11735                }
11736                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11737                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11738                }
11739            }
11740
11741            next_offset += envelope_size;
11742            _next_ordinal_to_read += 1;
11743            if next_offset >= end_offset {
11744                return Ok(());
11745            }
11746
11747            // Decode unknown envelopes for gaps in ordinals.
11748            while _next_ordinal_to_read < 3 {
11749                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11750                _next_ordinal_to_read += 1;
11751                next_offset += envelope_size;
11752            }
11753
11754            let next_out_of_line = decoder.next_out_of_line();
11755            let handles_before = decoder.remaining_handles();
11756            if let Some((inlined, num_bytes, num_handles)) =
11757                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11758            {
11759                let member_inline_size = <fidl::encoding::UnboundedVector<
11760                    fidl_fuchsia_bluetooth__common::Uuid,
11761                > as fidl::encoding::TypeMarker>::inline_size(
11762                    decoder.context
11763                );
11764                if inlined != (member_inline_size <= 4) {
11765                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11766                }
11767                let inner_offset;
11768                let mut inner_depth = depth.clone();
11769                if inlined {
11770                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11771                    inner_offset = next_offset;
11772                } else {
11773                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11774                    inner_depth.increment()?;
11775                }
11776                let val_ref = self.service_uuids.get_or_insert_with(|| {
11777                    fidl::new_empty!(
11778                        fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>,
11779                        D
11780                    )
11781                });
11782                fidl::decode!(
11783                    fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>,
11784                    D,
11785                    val_ref,
11786                    decoder,
11787                    inner_offset,
11788                    inner_depth
11789                )?;
11790                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11791                {
11792                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11793                }
11794                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11795                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11796                }
11797            }
11798
11799            next_offset += envelope_size;
11800            _next_ordinal_to_read += 1;
11801            if next_offset >= end_offset {
11802                return Ok(());
11803            }
11804
11805            // Decode unknown envelopes for gaps in ordinals.
11806            while _next_ordinal_to_read < 4 {
11807                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11808                _next_ordinal_to_read += 1;
11809                next_offset += envelope_size;
11810            }
11811
11812            let next_out_of_line = decoder.next_out_of_line();
11813            let handles_before = decoder.remaining_handles();
11814            if let Some((inlined, num_bytes, num_handles)) =
11815                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11816            {
11817                let member_inline_size = <fidl::encoding::UnboundedVector<ServiceData> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11818                if inlined != (member_inline_size <= 4) {
11819                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11820                }
11821                let inner_offset;
11822                let mut inner_depth = depth.clone();
11823                if inlined {
11824                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11825                    inner_offset = next_offset;
11826                } else {
11827                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11828                    inner_depth.increment()?;
11829                }
11830                let val_ref = self.service_data.get_or_insert_with(|| {
11831                    fidl::new_empty!(fidl::encoding::UnboundedVector<ServiceData>, D)
11832                });
11833                fidl::decode!(
11834                    fidl::encoding::UnboundedVector<ServiceData>,
11835                    D,
11836                    val_ref,
11837                    decoder,
11838                    inner_offset,
11839                    inner_depth
11840                )?;
11841                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11842                {
11843                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11844                }
11845                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11846                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11847                }
11848            }
11849
11850            next_offset += envelope_size;
11851            _next_ordinal_to_read += 1;
11852            if next_offset >= end_offset {
11853                return Ok(());
11854            }
11855
11856            // Decode unknown envelopes for gaps in ordinals.
11857            while _next_ordinal_to_read < 5 {
11858                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11859                _next_ordinal_to_read += 1;
11860                next_offset += envelope_size;
11861            }
11862
11863            let next_out_of_line = decoder.next_out_of_line();
11864            let handles_before = decoder.remaining_handles();
11865            if let Some((inlined, num_bytes, num_handles)) =
11866                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11867            {
11868                let member_inline_size = <fidl::encoding::UnboundedVector<ManufacturerData> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11869                if inlined != (member_inline_size <= 4) {
11870                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11871                }
11872                let inner_offset;
11873                let mut inner_depth = depth.clone();
11874                if inlined {
11875                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11876                    inner_offset = next_offset;
11877                } else {
11878                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11879                    inner_depth.increment()?;
11880                }
11881                let val_ref = self.manufacturer_data.get_or_insert_with(|| {
11882                    fidl::new_empty!(fidl::encoding::UnboundedVector<ManufacturerData>, D)
11883                });
11884                fidl::decode!(
11885                    fidl::encoding::UnboundedVector<ManufacturerData>,
11886                    D,
11887                    val_ref,
11888                    decoder,
11889                    inner_offset,
11890                    inner_depth
11891                )?;
11892                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11893                {
11894                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11895                }
11896                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11897                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11898                }
11899            }
11900
11901            next_offset += envelope_size;
11902            _next_ordinal_to_read += 1;
11903            if next_offset >= end_offset {
11904                return Ok(());
11905            }
11906
11907            // Decode unknown envelopes for gaps in ordinals.
11908            while _next_ordinal_to_read < 6 {
11909                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11910                _next_ordinal_to_read += 1;
11911                next_offset += envelope_size;
11912            }
11913
11914            let next_out_of_line = decoder.next_out_of_line();
11915            let handles_before = decoder.remaining_handles();
11916            if let Some((inlined, num_bytes, num_handles)) =
11917                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11918            {
11919                let member_inline_size = <fidl::encoding::UnboundedVector<
11920                    fidl::encoding::BoundedString<278>,
11921                > as fidl::encoding::TypeMarker>::inline_size(
11922                    decoder.context
11923                );
11924                if inlined != (member_inline_size <= 4) {
11925                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11926                }
11927                let inner_offset;
11928                let mut inner_depth = depth.clone();
11929                if inlined {
11930                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11931                    inner_offset = next_offset;
11932                } else {
11933                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11934                    inner_depth.increment()?;
11935                }
11936                let val_ref = self.uris.get_or_insert_with(|| {
11937                    fidl::new_empty!(
11938                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>,
11939                        D
11940                    )
11941                });
11942                fidl::decode!(
11943                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>,
11944                    D,
11945                    val_ref,
11946                    decoder,
11947                    inner_offset,
11948                    inner_depth
11949                )?;
11950                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11951                {
11952                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11953                }
11954                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11955                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11956                }
11957            }
11958
11959            next_offset += envelope_size;
11960            _next_ordinal_to_read += 1;
11961            if next_offset >= end_offset {
11962                return Ok(());
11963            }
11964
11965            // Decode unknown envelopes for gaps in ordinals.
11966            while _next_ordinal_to_read < 7 {
11967                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11968                _next_ordinal_to_read += 1;
11969                next_offset += envelope_size;
11970            }
11971
11972            let next_out_of_line = decoder.next_out_of_line();
11973            let handles_before = decoder.remaining_handles();
11974            if let Some((inlined, num_bytes, num_handles)) =
11975                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11976            {
11977                let member_inline_size =
11978                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11979                if inlined != (member_inline_size <= 4) {
11980                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11981                }
11982                let inner_offset;
11983                let mut inner_depth = depth.clone();
11984                if inlined {
11985                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11986                    inner_offset = next_offset;
11987                } else {
11988                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11989                    inner_depth.increment()?;
11990                }
11991                let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
11992                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
11993                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11994                {
11995                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11996                }
11997                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11998                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11999                }
12000            }
12001
12002            next_offset += envelope_size;
12003
12004            // Decode the remaining unknown envelopes.
12005            while next_offset < end_offset {
12006                _next_ordinal_to_read += 1;
12007                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12008                next_offset += envelope_size;
12009            }
12010
12011            Ok(())
12012        }
12013    }
12014
12015    impl ScanOptions {
12016        #[inline(always)]
12017        fn max_ordinal_present(&self) -> u64 {
12018            if let Some(_) = self.filters {
12019                return 1;
12020            }
12021            0
12022        }
12023    }
12024
12025    impl fidl::encoding::ValueTypeMarker for ScanOptions {
12026        type Borrowed<'a> = &'a Self;
12027        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12028            value
12029        }
12030    }
12031
12032    unsafe impl fidl::encoding::TypeMarker for ScanOptions {
12033        type Owned = Self;
12034
12035        #[inline(always)]
12036        fn inline_align(_context: fidl::encoding::Context) -> usize {
12037            8
12038        }
12039
12040        #[inline(always)]
12041        fn inline_size(_context: fidl::encoding::Context) -> usize {
12042            16
12043        }
12044    }
12045
12046    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ScanOptions, D>
12047        for &ScanOptions
12048    {
12049        unsafe fn encode(
12050            self,
12051            encoder: &mut fidl::encoding::Encoder<'_, D>,
12052            offset: usize,
12053            mut depth: fidl::encoding::Depth,
12054        ) -> fidl::Result<()> {
12055            encoder.debug_check_bounds::<ScanOptions>(offset);
12056            // Vector header
12057            let max_ordinal: u64 = self.max_ordinal_present();
12058            encoder.write_num(max_ordinal, offset);
12059            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12060            // Calling encoder.out_of_line_offset(0) is not allowed.
12061            if max_ordinal == 0 {
12062                return Ok(());
12063            }
12064            depth.increment()?;
12065            let envelope_size = 8;
12066            let bytes_len = max_ordinal as usize * envelope_size;
12067            #[allow(unused_variables)]
12068            let offset = encoder.out_of_line_offset(bytes_len);
12069            let mut _prev_end_offset: usize = 0;
12070            if 1 > max_ordinal {
12071                return Ok(());
12072            }
12073
12074            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12075            // are envelope_size bytes.
12076            let cur_offset: usize = (1 - 1) * envelope_size;
12077
12078            // Zero reserved fields.
12079            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12080
12081            // Safety:
12082            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12083            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12084            //   envelope_size bytes, there is always sufficient room.
12085            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Filter>, D>(
12086            self.filters.as_ref().map(<fidl::encoding::UnboundedVector<Filter> as fidl::encoding::ValueTypeMarker>::borrow),
12087            encoder, offset + cur_offset, depth
12088        )?;
12089
12090            _prev_end_offset = cur_offset + envelope_size;
12091
12092            Ok(())
12093        }
12094    }
12095
12096    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanOptions {
12097        #[inline(always)]
12098        fn new_empty() -> Self {
12099            Self::default()
12100        }
12101
12102        unsafe fn decode(
12103            &mut self,
12104            decoder: &mut fidl::encoding::Decoder<'_, D>,
12105            offset: usize,
12106            mut depth: fidl::encoding::Depth,
12107        ) -> fidl::Result<()> {
12108            decoder.debug_check_bounds::<Self>(offset);
12109            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12110                None => return Err(fidl::Error::NotNullable),
12111                Some(len) => len,
12112            };
12113            // Calling decoder.out_of_line_offset(0) is not allowed.
12114            if len == 0 {
12115                return Ok(());
12116            };
12117            depth.increment()?;
12118            let envelope_size = 8;
12119            let bytes_len = len * envelope_size;
12120            let offset = decoder.out_of_line_offset(bytes_len)?;
12121            // Decode the envelope for each type.
12122            let mut _next_ordinal_to_read = 0;
12123            let mut next_offset = offset;
12124            let end_offset = offset + bytes_len;
12125            _next_ordinal_to_read += 1;
12126            if next_offset >= end_offset {
12127                return Ok(());
12128            }
12129
12130            // Decode unknown envelopes for gaps in ordinals.
12131            while _next_ordinal_to_read < 1 {
12132                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12133                _next_ordinal_to_read += 1;
12134                next_offset += envelope_size;
12135            }
12136
12137            let next_out_of_line = decoder.next_out_of_line();
12138            let handles_before = decoder.remaining_handles();
12139            if let Some((inlined, num_bytes, num_handles)) =
12140                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12141            {
12142                let member_inline_size = <fidl::encoding::UnboundedVector<Filter> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12143                if inlined != (member_inline_size <= 4) {
12144                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12145                }
12146                let inner_offset;
12147                let mut inner_depth = depth.clone();
12148                if inlined {
12149                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12150                    inner_offset = next_offset;
12151                } else {
12152                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12153                    inner_depth.increment()?;
12154                }
12155                let val_ref = self.filters.get_or_insert_with(|| {
12156                    fidl::new_empty!(fidl::encoding::UnboundedVector<Filter>, D)
12157                });
12158                fidl::decode!(
12159                    fidl::encoding::UnboundedVector<Filter>,
12160                    D,
12161                    val_ref,
12162                    decoder,
12163                    inner_offset,
12164                    inner_depth
12165                )?;
12166                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12167                {
12168                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12169                }
12170                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12171                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12172                }
12173            }
12174
12175            next_offset += envelope_size;
12176
12177            // Decode the remaining unknown envelopes.
12178            while next_offset < end_offset {
12179                _next_ordinal_to_read += 1;
12180                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12181                next_offset += envelope_size;
12182            }
12183
12184            Ok(())
12185        }
12186    }
12187
12188    impl fidl::encoding::ValueTypeMarker for AdvertisingProcedure {
12189        type Borrowed<'a> = &'a Self;
12190        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12191            value
12192        }
12193    }
12194
12195    unsafe impl fidl::encoding::TypeMarker for AdvertisingProcedure {
12196        type Owned = Self;
12197
12198        #[inline(always)]
12199        fn inline_align(_context: fidl::encoding::Context) -> usize {
12200            8
12201        }
12202
12203        #[inline(always)]
12204        fn inline_size(_context: fidl::encoding::Context) -> usize {
12205            16
12206        }
12207    }
12208
12209    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AdvertisingProcedure, D>
12210        for &AdvertisingProcedure
12211    {
12212        #[inline]
12213        unsafe fn encode(
12214            self,
12215            encoder: &mut fidl::encoding::Encoder<'_, D>,
12216            offset: usize,
12217            _depth: fidl::encoding::Depth,
12218        ) -> fidl::Result<()> {
12219            encoder.debug_check_bounds::<AdvertisingProcedure>(offset);
12220            encoder.write_num::<u64>(self.ordinal(), offset);
12221            match self {
12222                AdvertisingProcedure::Legacy(ref val) => {
12223                    fidl::encoding::encode_in_envelope::<Legacy, D>(
12224                        <Legacy as fidl::encoding::ValueTypeMarker>::borrow(val),
12225                        encoder,
12226                        offset + 8,
12227                        _depth,
12228                    )
12229                }
12230                AdvertisingProcedure::Extended(ref val) => {
12231                    fidl::encoding::encode_in_envelope::<Extended, D>(
12232                        <Extended as fidl::encoding::ValueTypeMarker>::borrow(val),
12233                        encoder,
12234                        offset + 8,
12235                        _depth,
12236                    )
12237                }
12238                AdvertisingProcedure::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
12239            }
12240        }
12241    }
12242
12243    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvertisingProcedure {
12244        #[inline(always)]
12245        fn new_empty() -> Self {
12246            Self::__SourceBreaking { unknown_ordinal: 0 }
12247        }
12248
12249        #[inline]
12250        unsafe fn decode(
12251            &mut self,
12252            decoder: &mut fidl::encoding::Decoder<'_, D>,
12253            offset: usize,
12254            mut depth: fidl::encoding::Depth,
12255        ) -> fidl::Result<()> {
12256            decoder.debug_check_bounds::<Self>(offset);
12257            #[allow(unused_variables)]
12258            let next_out_of_line = decoder.next_out_of_line();
12259            let handles_before = decoder.remaining_handles();
12260            let (ordinal, inlined, num_bytes, num_handles) =
12261                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
12262
12263            let member_inline_size = match ordinal {
12264                1 => <Legacy as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12265                2 => <Extended as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12266                0 => return Err(fidl::Error::UnknownUnionTag),
12267                _ => num_bytes as usize,
12268            };
12269
12270            if inlined != (member_inline_size <= 4) {
12271                return Err(fidl::Error::InvalidInlineBitInEnvelope);
12272            }
12273            let _inner_offset;
12274            if inlined {
12275                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
12276                _inner_offset = offset + 8;
12277            } else {
12278                depth.increment()?;
12279                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12280            }
12281            match ordinal {
12282                1 => {
12283                    #[allow(irrefutable_let_patterns)]
12284                    if let AdvertisingProcedure::Legacy(_) = self {
12285                        // Do nothing, read the value into the object
12286                    } else {
12287                        // Initialize `self` to the right variant
12288                        *self = AdvertisingProcedure::Legacy(fidl::new_empty!(Legacy, D));
12289                    }
12290                    #[allow(irrefutable_let_patterns)]
12291                    if let AdvertisingProcedure::Legacy(ref mut val) = self {
12292                        fidl::decode!(Legacy, D, val, decoder, _inner_offset, depth)?;
12293                    } else {
12294                        unreachable!()
12295                    }
12296                }
12297                2 => {
12298                    #[allow(irrefutable_let_patterns)]
12299                    if let AdvertisingProcedure::Extended(_) = self {
12300                        // Do nothing, read the value into the object
12301                    } else {
12302                        // Initialize `self` to the right variant
12303                        *self = AdvertisingProcedure::Extended(fidl::new_empty!(Extended, D));
12304                    }
12305                    #[allow(irrefutable_let_patterns)]
12306                    if let AdvertisingProcedure::Extended(ref mut val) = self {
12307                        fidl::decode!(Extended, D, val, decoder, _inner_offset, depth)?;
12308                    } else {
12309                        unreachable!()
12310                    }
12311                }
12312                #[allow(deprecated)]
12313                ordinal => {
12314                    for _ in 0..num_handles {
12315                        decoder.drop_next_handle()?;
12316                    }
12317                    *self = AdvertisingProcedure::__SourceBreaking { unknown_ordinal: ordinal };
12318                }
12319            }
12320            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
12321                return Err(fidl::Error::InvalidNumBytesInEnvelope);
12322            }
12323            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12324                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12325            }
12326            Ok(())
12327        }
12328    }
12329}