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
1160mod internal {
1161    use super::*;
1162    unsafe impl fidl::encoding::TypeMarker for AdvertisingModeHint {
1163        type Owned = Self;
1164
1165        #[inline(always)]
1166        fn inline_align(_context: fidl::encoding::Context) -> usize {
1167            std::mem::align_of::<u8>()
1168        }
1169
1170        #[inline(always)]
1171        fn inline_size(_context: fidl::encoding::Context) -> usize {
1172            std::mem::size_of::<u8>()
1173        }
1174
1175        #[inline(always)]
1176        fn encode_is_copy() -> bool {
1177            true
1178        }
1179
1180        #[inline(always)]
1181        fn decode_is_copy() -> bool {
1182            false
1183        }
1184    }
1185
1186    impl fidl::encoding::ValueTypeMarker for AdvertisingModeHint {
1187        type Borrowed<'a> = Self;
1188        #[inline(always)]
1189        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1190            *value
1191        }
1192    }
1193
1194    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1195        for AdvertisingModeHint
1196    {
1197        #[inline]
1198        unsafe fn encode(
1199            self,
1200            encoder: &mut fidl::encoding::Encoder<'_, D>,
1201            offset: usize,
1202            _depth: fidl::encoding::Depth,
1203        ) -> fidl::Result<()> {
1204            encoder.debug_check_bounds::<Self>(offset);
1205            encoder.write_num(self.into_primitive(), offset);
1206            Ok(())
1207        }
1208    }
1209
1210    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvertisingModeHint {
1211        #[inline(always)]
1212        fn new_empty() -> Self {
1213            Self::VeryFast
1214        }
1215
1216        #[inline]
1217        unsafe fn decode(
1218            &mut self,
1219            decoder: &mut fidl::encoding::Decoder<'_, D>,
1220            offset: usize,
1221            _depth: fidl::encoding::Depth,
1222        ) -> fidl::Result<()> {
1223            decoder.debug_check_bounds::<Self>(offset);
1224            let prim = decoder.read_num::<u8>(offset);
1225
1226            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1227            Ok(())
1228        }
1229    }
1230    unsafe impl fidl::encoding::TypeMarker for CentralError {
1231        type Owned = Self;
1232
1233        #[inline(always)]
1234        fn inline_align(_context: fidl::encoding::Context) -> usize {
1235            std::mem::align_of::<u32>()
1236        }
1237
1238        #[inline(always)]
1239        fn inline_size(_context: fidl::encoding::Context) -> usize {
1240            std::mem::size_of::<u32>()
1241        }
1242
1243        #[inline(always)]
1244        fn encode_is_copy() -> bool {
1245            true
1246        }
1247
1248        #[inline(always)]
1249        fn decode_is_copy() -> bool {
1250            false
1251        }
1252    }
1253
1254    impl fidl::encoding::ValueTypeMarker for CentralError {
1255        type Borrowed<'a> = Self;
1256        #[inline(always)]
1257        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1258            *value
1259        }
1260    }
1261
1262    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CentralError {
1263        #[inline]
1264        unsafe fn encode(
1265            self,
1266            encoder: &mut fidl::encoding::Encoder<'_, D>,
1267            offset: usize,
1268            _depth: fidl::encoding::Depth,
1269        ) -> fidl::Result<()> {
1270            encoder.debug_check_bounds::<Self>(offset);
1271            encoder.write_num(self.into_primitive(), offset);
1272            Ok(())
1273        }
1274    }
1275
1276    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CentralError {
1277        #[inline(always)]
1278        fn new_empty() -> Self {
1279            Self::Aborted
1280        }
1281
1282        #[inline]
1283        unsafe fn decode(
1284            &mut self,
1285            decoder: &mut fidl::encoding::Decoder<'_, D>,
1286            offset: usize,
1287            _depth: fidl::encoding::Depth,
1288        ) -> fidl::Result<()> {
1289            decoder.debug_check_bounds::<Self>(offset);
1290            let prim = decoder.read_num::<u32>(offset);
1291
1292            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1293            Ok(())
1294        }
1295    }
1296    unsafe impl fidl::encoding::TypeMarker for CigFramingOptions {
1297        type Owned = Self;
1298
1299        #[inline(always)]
1300        fn inline_align(_context: fidl::encoding::Context) -> usize {
1301            std::mem::align_of::<u32>()
1302        }
1303
1304        #[inline(always)]
1305        fn inline_size(_context: fidl::encoding::Context) -> usize {
1306            std::mem::size_of::<u32>()
1307        }
1308
1309        #[inline(always)]
1310        fn encode_is_copy() -> bool {
1311            true
1312        }
1313
1314        #[inline(always)]
1315        fn decode_is_copy() -> bool {
1316            false
1317        }
1318    }
1319
1320    impl fidl::encoding::ValueTypeMarker for CigFramingOptions {
1321        type Borrowed<'a> = Self;
1322        #[inline(always)]
1323        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1324            *value
1325        }
1326    }
1327
1328    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1329        for CigFramingOptions
1330    {
1331        #[inline]
1332        unsafe fn encode(
1333            self,
1334            encoder: &mut fidl::encoding::Encoder<'_, D>,
1335            offset: usize,
1336            _depth: fidl::encoding::Depth,
1337        ) -> fidl::Result<()> {
1338            encoder.debug_check_bounds::<Self>(offset);
1339            encoder.write_num(self.into_primitive(), offset);
1340            Ok(())
1341        }
1342    }
1343
1344    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CigFramingOptions {
1345        #[inline(always)]
1346        fn new_empty() -> Self {
1347            Self::Unframed
1348        }
1349
1350        #[inline]
1351        unsafe fn decode(
1352            &mut self,
1353            decoder: &mut fidl::encoding::Decoder<'_, D>,
1354            offset: usize,
1355            _depth: fidl::encoding::Depth,
1356        ) -> fidl::Result<()> {
1357            decoder.debug_check_bounds::<Self>(offset);
1358            let prim = decoder.read_num::<u32>(offset);
1359
1360            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1361            Ok(())
1362        }
1363    }
1364    unsafe impl fidl::encoding::TypeMarker for CigPacking {
1365        type Owned = Self;
1366
1367        #[inline(always)]
1368        fn inline_align(_context: fidl::encoding::Context) -> usize {
1369            std::mem::align_of::<u32>()
1370        }
1371
1372        #[inline(always)]
1373        fn inline_size(_context: fidl::encoding::Context) -> usize {
1374            std::mem::size_of::<u32>()
1375        }
1376
1377        #[inline(always)]
1378        fn encode_is_copy() -> bool {
1379            false
1380        }
1381
1382        #[inline(always)]
1383        fn decode_is_copy() -> bool {
1384            false
1385        }
1386    }
1387
1388    impl fidl::encoding::ValueTypeMarker for CigPacking {
1389        type Borrowed<'a> = Self;
1390        #[inline(always)]
1391        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1392            *value
1393        }
1394    }
1395
1396    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CigPacking {
1397        #[inline]
1398        unsafe fn encode(
1399            self,
1400            encoder: &mut fidl::encoding::Encoder<'_, D>,
1401            offset: usize,
1402            _depth: fidl::encoding::Depth,
1403        ) -> fidl::Result<()> {
1404            encoder.debug_check_bounds::<Self>(offset);
1405            encoder.write_num(self.into_primitive(), offset);
1406            Ok(())
1407        }
1408    }
1409
1410    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CigPacking {
1411        #[inline(always)]
1412        fn new_empty() -> Self {
1413            Self::unknown()
1414        }
1415
1416        #[inline]
1417        unsafe fn decode(
1418            &mut self,
1419            decoder: &mut fidl::encoding::Decoder<'_, D>,
1420            offset: usize,
1421            _depth: fidl::encoding::Depth,
1422        ) -> fidl::Result<()> {
1423            decoder.debug_check_bounds::<Self>(offset);
1424            let prim = decoder.read_num::<u32>(offset);
1425
1426            *self = Self::from_primitive_allow_unknown(prim);
1427            Ok(())
1428        }
1429    }
1430    unsafe impl fidl::encoding::TypeMarker for CreateCigError {
1431        type Owned = Self;
1432
1433        #[inline(always)]
1434        fn inline_align(_context: fidl::encoding::Context) -> usize {
1435            std::mem::align_of::<u32>()
1436        }
1437
1438        #[inline(always)]
1439        fn inline_size(_context: fidl::encoding::Context) -> usize {
1440            std::mem::size_of::<u32>()
1441        }
1442
1443        #[inline(always)]
1444        fn encode_is_copy() -> bool {
1445            false
1446        }
1447
1448        #[inline(always)]
1449        fn decode_is_copy() -> bool {
1450            false
1451        }
1452    }
1453
1454    impl fidl::encoding::ValueTypeMarker for CreateCigError {
1455        type Borrowed<'a> = Self;
1456        #[inline(always)]
1457        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1458            *value
1459        }
1460    }
1461
1462    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for CreateCigError {
1463        #[inline]
1464        unsafe fn encode(
1465            self,
1466            encoder: &mut fidl::encoding::Encoder<'_, D>,
1467            offset: usize,
1468            _depth: fidl::encoding::Depth,
1469        ) -> fidl::Result<()> {
1470            encoder.debug_check_bounds::<Self>(offset);
1471            encoder.write_num(self.into_primitive(), offset);
1472            Ok(())
1473        }
1474    }
1475
1476    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CreateCigError {
1477        #[inline(always)]
1478        fn new_empty() -> Self {
1479            Self::unknown()
1480        }
1481
1482        #[inline]
1483        unsafe fn decode(
1484            &mut self,
1485            decoder: &mut fidl::encoding::Decoder<'_, D>,
1486            offset: usize,
1487            _depth: fidl::encoding::Depth,
1488        ) -> fidl::Result<()> {
1489            decoder.debug_check_bounds::<Self>(offset);
1490            let prim = decoder.read_num::<u32>(offset);
1491
1492            *self = Self::from_primitive_allow_unknown(prim);
1493            Ok(())
1494        }
1495    }
1496    unsafe impl fidl::encoding::TypeMarker for EstablishStreamsError {
1497        type Owned = Self;
1498
1499        #[inline(always)]
1500        fn inline_align(_context: fidl::encoding::Context) -> usize {
1501            std::mem::align_of::<u32>()
1502        }
1503
1504        #[inline(always)]
1505        fn inline_size(_context: fidl::encoding::Context) -> usize {
1506            std::mem::size_of::<u32>()
1507        }
1508
1509        #[inline(always)]
1510        fn encode_is_copy() -> bool {
1511            false
1512        }
1513
1514        #[inline(always)]
1515        fn decode_is_copy() -> bool {
1516            false
1517        }
1518    }
1519
1520    impl fidl::encoding::ValueTypeMarker for EstablishStreamsError {
1521        type Borrowed<'a> = Self;
1522        #[inline(always)]
1523        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1524            *value
1525        }
1526    }
1527
1528    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1529        for EstablishStreamsError
1530    {
1531        #[inline]
1532        unsafe fn encode(
1533            self,
1534            encoder: &mut fidl::encoding::Encoder<'_, D>,
1535            offset: usize,
1536            _depth: fidl::encoding::Depth,
1537        ) -> fidl::Result<()> {
1538            encoder.debug_check_bounds::<Self>(offset);
1539            encoder.write_num(self.into_primitive(), offset);
1540            Ok(())
1541        }
1542    }
1543
1544    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EstablishStreamsError {
1545        #[inline(always)]
1546        fn new_empty() -> Self {
1547            Self::unknown()
1548        }
1549
1550        #[inline]
1551        unsafe fn decode(
1552            &mut self,
1553            decoder: &mut fidl::encoding::Decoder<'_, D>,
1554            offset: usize,
1555            _depth: fidl::encoding::Depth,
1556        ) -> fidl::Result<()> {
1557            decoder.debug_check_bounds::<Self>(offset);
1558            let prim = decoder.read_num::<u32>(offset);
1559
1560            *self = Self::from_primitive_allow_unknown(prim);
1561            Ok(())
1562        }
1563    }
1564    unsafe impl fidl::encoding::TypeMarker for IsoPacketStatusFlag {
1565        type Owned = Self;
1566
1567        #[inline(always)]
1568        fn inline_align(_context: fidl::encoding::Context) -> usize {
1569            std::mem::align_of::<u8>()
1570        }
1571
1572        #[inline(always)]
1573        fn inline_size(_context: fidl::encoding::Context) -> usize {
1574            std::mem::size_of::<u8>()
1575        }
1576
1577        #[inline(always)]
1578        fn encode_is_copy() -> bool {
1579            true
1580        }
1581
1582        #[inline(always)]
1583        fn decode_is_copy() -> bool {
1584            false
1585        }
1586    }
1587
1588    impl fidl::encoding::ValueTypeMarker for IsoPacketStatusFlag {
1589        type Borrowed<'a> = Self;
1590        #[inline(always)]
1591        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1592            *value
1593        }
1594    }
1595
1596    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1597        for IsoPacketStatusFlag
1598    {
1599        #[inline]
1600        unsafe fn encode(
1601            self,
1602            encoder: &mut fidl::encoding::Encoder<'_, D>,
1603            offset: usize,
1604            _depth: fidl::encoding::Depth,
1605        ) -> fidl::Result<()> {
1606            encoder.debug_check_bounds::<Self>(offset);
1607            encoder.write_num(self.into_primitive(), offset);
1608            Ok(())
1609        }
1610    }
1611
1612    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IsoPacketStatusFlag {
1613        #[inline(always)]
1614        fn new_empty() -> Self {
1615            Self::ValidData
1616        }
1617
1618        #[inline]
1619        unsafe fn decode(
1620            &mut self,
1621            decoder: &mut fidl::encoding::Decoder<'_, D>,
1622            offset: usize,
1623            _depth: fidl::encoding::Depth,
1624        ) -> fidl::Result<()> {
1625            decoder.debug_check_bounds::<Self>(offset);
1626            let prim = decoder.read_num::<u8>(offset);
1627
1628            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1629            Ok(())
1630        }
1631    }
1632    unsafe impl fidl::encoding::TypeMarker for PeripheralError {
1633        type Owned = Self;
1634
1635        #[inline(always)]
1636        fn inline_align(_context: fidl::encoding::Context) -> usize {
1637            std::mem::align_of::<u32>()
1638        }
1639
1640        #[inline(always)]
1641        fn inline_size(_context: fidl::encoding::Context) -> usize {
1642            std::mem::size_of::<u32>()
1643        }
1644
1645        #[inline(always)]
1646        fn encode_is_copy() -> bool {
1647            true
1648        }
1649
1650        #[inline(always)]
1651        fn decode_is_copy() -> bool {
1652            false
1653        }
1654    }
1655
1656    impl fidl::encoding::ValueTypeMarker for PeripheralError {
1657        type Borrowed<'a> = Self;
1658        #[inline(always)]
1659        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1660            *value
1661        }
1662    }
1663
1664    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1665        for PeripheralError
1666    {
1667        #[inline]
1668        unsafe fn encode(
1669            self,
1670            encoder: &mut fidl::encoding::Encoder<'_, D>,
1671            offset: usize,
1672            _depth: fidl::encoding::Depth,
1673        ) -> fidl::Result<()> {
1674            encoder.debug_check_bounds::<Self>(offset);
1675            encoder.write_num(self.into_primitive(), offset);
1676            Ok(())
1677        }
1678    }
1679
1680    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PeripheralError {
1681        #[inline(always)]
1682        fn new_empty() -> Self {
1683            Self::NotSupported
1684        }
1685
1686        #[inline]
1687        unsafe fn decode(
1688            &mut self,
1689            decoder: &mut fidl::encoding::Decoder<'_, D>,
1690            offset: usize,
1691            _depth: fidl::encoding::Depth,
1692        ) -> fidl::Result<()> {
1693            decoder.debug_check_bounds::<Self>(offset);
1694            let prim = decoder.read_num::<u32>(offset);
1695
1696            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1697            Ok(())
1698        }
1699    }
1700
1701    impl fidl::encoding::ValueTypeMarker for AdvertisingDataDeprecated {
1702        type Borrowed<'a> = &'a Self;
1703        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1704            value
1705        }
1706    }
1707
1708    unsafe impl fidl::encoding::TypeMarker for AdvertisingDataDeprecated {
1709        type Owned = Self;
1710
1711        #[inline(always)]
1712        fn inline_align(_context: fidl::encoding::Context) -> usize {
1713            8
1714        }
1715
1716        #[inline(always)]
1717        fn inline_size(_context: fidl::encoding::Context) -> usize {
1718            112
1719        }
1720    }
1721
1722    unsafe impl<D: fidl::encoding::ResourceDialect>
1723        fidl::encoding::Encode<AdvertisingDataDeprecated, D> for &AdvertisingDataDeprecated
1724    {
1725        #[inline]
1726        unsafe fn encode(
1727            self,
1728            encoder: &mut fidl::encoding::Encoder<'_, D>,
1729            offset: usize,
1730            _depth: fidl::encoding::Depth,
1731        ) -> fidl::Result<()> {
1732            encoder.debug_check_bounds::<AdvertisingDataDeprecated>(offset);
1733            // Delegate to tuple encoding.
1734            fidl::encoding::Encode::<AdvertisingDataDeprecated, D>::encode(
1735                (
1736                    <fidl::encoding::Optional<fidl::encoding::BoundedString<248>> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
1737                    <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8> as fidl::encoding::ValueTypeMarker>::borrow(&self.tx_power_level),
1738                    <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16> as fidl::encoding::ValueTypeMarker>::borrow(&self.appearance),
1739                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.service_uuids),
1740                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<ServiceDataEntry>> as fidl::encoding::ValueTypeMarker>::borrow(&self.service_data),
1741                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<ManufacturerSpecificDataEntry>> as fidl::encoding::ValueTypeMarker>::borrow(&self.manufacturer_specific_data),
1742                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.solicited_service_uuids),
1743                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>> as fidl::encoding::ValueTypeMarker>::borrow(&self.uris),
1744                ),
1745                encoder, offset, _depth
1746            )
1747        }
1748    }
1749    unsafe impl<
1750            D: fidl::encoding::ResourceDialect,
1751            T0: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<248>>, D>,
1752            T1: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>, D>,
1753            T2: fidl::encoding::Encode<
1754                fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
1755                D,
1756            >,
1757            T3: fidl::encoding::Encode<
1758                fidl::encoding::Optional<
1759                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1760                >,
1761                D,
1762            >,
1763            T4: fidl::encoding::Encode<
1764                fidl::encoding::Optional<fidl::encoding::UnboundedVector<ServiceDataEntry>>,
1765                D,
1766            >,
1767            T5: fidl::encoding::Encode<
1768                fidl::encoding::Optional<
1769                    fidl::encoding::UnboundedVector<ManufacturerSpecificDataEntry>,
1770                >,
1771                D,
1772            >,
1773            T6: fidl::encoding::Encode<
1774                fidl::encoding::Optional<
1775                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1776                >,
1777                D,
1778            >,
1779            T7: fidl::encoding::Encode<
1780                fidl::encoding::Optional<
1781                    fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
1782                >,
1783                D,
1784            >,
1785        > fidl::encoding::Encode<AdvertisingDataDeprecated, D>
1786        for (T0, T1, T2, T3, T4, T5, T6, T7)
1787    {
1788        #[inline]
1789        unsafe fn encode(
1790            self,
1791            encoder: &mut fidl::encoding::Encoder<'_, D>,
1792            offset: usize,
1793            depth: fidl::encoding::Depth,
1794        ) -> fidl::Result<()> {
1795            encoder.debug_check_bounds::<AdvertisingDataDeprecated>(offset);
1796            // Zero out padding regions. There's no need to apply masks
1797            // because the unmasked parts will be overwritten by fields.
1798            // Write the fields.
1799            self.0.encode(encoder, offset + 0, depth)?;
1800            self.1.encode(encoder, offset + 16, depth)?;
1801            self.2.encode(encoder, offset + 24, depth)?;
1802            self.3.encode(encoder, offset + 32, depth)?;
1803            self.4.encode(encoder, offset + 48, depth)?;
1804            self.5.encode(encoder, offset + 64, depth)?;
1805            self.6.encode(encoder, offset + 80, depth)?;
1806            self.7.encode(encoder, offset + 96, depth)?;
1807            Ok(())
1808        }
1809    }
1810
1811    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1812        for AdvertisingDataDeprecated
1813    {
1814        #[inline(always)]
1815        fn new_empty() -> Self {
1816            Self {
1817                name: fidl::new_empty!(
1818                    fidl::encoding::Optional<fidl::encoding::BoundedString<248>>,
1819                    D
1820                ),
1821                tx_power_level: fidl::new_empty!(
1822                    fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
1823                    D
1824                ),
1825                appearance: fidl::new_empty!(
1826                    fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
1827                    D
1828                ),
1829                service_uuids: fidl::new_empty!(
1830                    fidl::encoding::Optional<
1831                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1832                    >,
1833                    D
1834                ),
1835                service_data: fidl::new_empty!(
1836                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<ServiceDataEntry>>,
1837                    D
1838                ),
1839                manufacturer_specific_data: fidl::new_empty!(
1840                    fidl::encoding::Optional<
1841                        fidl::encoding::UnboundedVector<ManufacturerSpecificDataEntry>,
1842                    >,
1843                    D
1844                ),
1845                solicited_service_uuids: fidl::new_empty!(
1846                    fidl::encoding::Optional<
1847                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1848                    >,
1849                    D
1850                ),
1851                uris: fidl::new_empty!(
1852                    fidl::encoding::Optional<
1853                        fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
1854                    >,
1855                    D
1856                ),
1857            }
1858        }
1859
1860        #[inline]
1861        unsafe fn decode(
1862            &mut self,
1863            decoder: &mut fidl::encoding::Decoder<'_, D>,
1864            offset: usize,
1865            _depth: fidl::encoding::Depth,
1866        ) -> fidl::Result<()> {
1867            decoder.debug_check_bounds::<Self>(offset);
1868            // Verify that padding bytes are zero.
1869            fidl::decode!(
1870                fidl::encoding::Optional<fidl::encoding::BoundedString<248>>,
1871                D,
1872                &mut self.name,
1873                decoder,
1874                offset + 0,
1875                _depth
1876            )?;
1877            fidl::decode!(
1878                fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
1879                D,
1880                &mut self.tx_power_level,
1881                decoder,
1882                offset + 16,
1883                _depth
1884            )?;
1885            fidl::decode!(
1886                fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
1887                D,
1888                &mut self.appearance,
1889                decoder,
1890                offset + 24,
1891                _depth
1892            )?;
1893            fidl::decode!(
1894                fidl::encoding::Optional<
1895                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1896                >,
1897                D,
1898                &mut self.service_uuids,
1899                decoder,
1900                offset + 32,
1901                _depth
1902            )?;
1903            fidl::decode!(
1904                fidl::encoding::Optional<fidl::encoding::UnboundedVector<ServiceDataEntry>>,
1905                D,
1906                &mut self.service_data,
1907                decoder,
1908                offset + 48,
1909                _depth
1910            )?;
1911            fidl::decode!(
1912                fidl::encoding::Optional<
1913                    fidl::encoding::UnboundedVector<ManufacturerSpecificDataEntry>,
1914                >,
1915                D,
1916                &mut self.manufacturer_specific_data,
1917                decoder,
1918                offset + 64,
1919                _depth
1920            )?;
1921            fidl::decode!(
1922                fidl::encoding::Optional<
1923                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
1924                >,
1925                D,
1926                &mut self.solicited_service_uuids,
1927                decoder,
1928                offset + 80,
1929                _depth
1930            )?;
1931            fidl::decode!(
1932                fidl::encoding::Optional<
1933                    fidl::encoding::UnboundedVector<fidl::encoding::UnboundedString>,
1934                >,
1935                D,
1936                &mut self.uris,
1937                decoder,
1938                offset + 96,
1939                _depth
1940            )?;
1941            Ok(())
1942        }
1943    }
1944
1945    impl fidl::encoding::ValueTypeMarker for CentralConnectPeripheralResponse {
1946        type Borrowed<'a> = &'a Self;
1947        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1948            value
1949        }
1950    }
1951
1952    unsafe impl fidl::encoding::TypeMarker for CentralConnectPeripheralResponse {
1953        type Owned = Self;
1954
1955        #[inline(always)]
1956        fn inline_align(_context: fidl::encoding::Context) -> usize {
1957            8
1958        }
1959
1960        #[inline(always)]
1961        fn inline_size(_context: fidl::encoding::Context) -> usize {
1962            8
1963        }
1964    }
1965
1966    unsafe impl<D: fidl::encoding::ResourceDialect>
1967        fidl::encoding::Encode<CentralConnectPeripheralResponse, D>
1968        for &CentralConnectPeripheralResponse
1969    {
1970        #[inline]
1971        unsafe fn encode(
1972            self,
1973            encoder: &mut fidl::encoding::Encoder<'_, D>,
1974            offset: usize,
1975            _depth: fidl::encoding::Depth,
1976        ) -> fidl::Result<()> {
1977            encoder.debug_check_bounds::<CentralConnectPeripheralResponse>(offset);
1978            // Delegate to tuple encoding.
1979            fidl::encoding::Encode::<CentralConnectPeripheralResponse, D>::encode(
1980                (
1981                    <fidl_fuchsia_bluetooth__common::Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
1982                ),
1983                encoder, offset, _depth
1984            )
1985        }
1986    }
1987    unsafe impl<
1988            D: fidl::encoding::ResourceDialect,
1989            T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::Status, D>,
1990        > fidl::encoding::Encode<CentralConnectPeripheralResponse, D> for (T0,)
1991    {
1992        #[inline]
1993        unsafe fn encode(
1994            self,
1995            encoder: &mut fidl::encoding::Encoder<'_, D>,
1996            offset: usize,
1997            depth: fidl::encoding::Depth,
1998        ) -> fidl::Result<()> {
1999            encoder.debug_check_bounds::<CentralConnectPeripheralResponse>(offset);
2000            // Zero out padding regions. There's no need to apply masks
2001            // because the unmasked parts will be overwritten by fields.
2002            // Write the fields.
2003            self.0.encode(encoder, offset + 0, depth)?;
2004            Ok(())
2005        }
2006    }
2007
2008    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2009        for CentralConnectPeripheralResponse
2010    {
2011        #[inline(always)]
2012        fn new_empty() -> Self {
2013            Self { status: fidl::new_empty!(fidl_fuchsia_bluetooth__common::Status, D) }
2014        }
2015
2016        #[inline]
2017        unsafe fn decode(
2018            &mut self,
2019            decoder: &mut fidl::encoding::Decoder<'_, D>,
2020            offset: usize,
2021            _depth: fidl::encoding::Depth,
2022        ) -> fidl::Result<()> {
2023            decoder.debug_check_bounds::<Self>(offset);
2024            // Verify that padding bytes are zero.
2025            fidl::decode!(
2026                fidl_fuchsia_bluetooth__common::Status,
2027                D,
2028                &mut self.status,
2029                decoder,
2030                offset + 0,
2031                _depth
2032            )?;
2033            Ok(())
2034        }
2035    }
2036
2037    impl fidl::encoding::ValueTypeMarker for CentralDisconnectPeripheralRequest {
2038        type Borrowed<'a> = &'a Self;
2039        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2040            value
2041        }
2042    }
2043
2044    unsafe impl fidl::encoding::TypeMarker for CentralDisconnectPeripheralRequest {
2045        type Owned = Self;
2046
2047        #[inline(always)]
2048        fn inline_align(_context: fidl::encoding::Context) -> usize {
2049            8
2050        }
2051
2052        #[inline(always)]
2053        fn inline_size(_context: fidl::encoding::Context) -> usize {
2054            16
2055        }
2056    }
2057
2058    unsafe impl<D: fidl::encoding::ResourceDialect>
2059        fidl::encoding::Encode<CentralDisconnectPeripheralRequest, D>
2060        for &CentralDisconnectPeripheralRequest
2061    {
2062        #[inline]
2063        unsafe fn encode(
2064            self,
2065            encoder: &mut fidl::encoding::Encoder<'_, D>,
2066            offset: usize,
2067            _depth: fidl::encoding::Depth,
2068        ) -> fidl::Result<()> {
2069            encoder.debug_check_bounds::<CentralDisconnectPeripheralRequest>(offset);
2070            // Delegate to tuple encoding.
2071            fidl::encoding::Encode::<CentralDisconnectPeripheralRequest, D>::encode(
2072                (<fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow(
2073                    &self.identifier,
2074                ),),
2075                encoder,
2076                offset,
2077                _depth,
2078            )
2079        }
2080    }
2081    unsafe impl<
2082            D: fidl::encoding::ResourceDialect,
2083            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<16>, D>,
2084        > fidl::encoding::Encode<CentralDisconnectPeripheralRequest, D> for (T0,)
2085    {
2086        #[inline]
2087        unsafe fn encode(
2088            self,
2089            encoder: &mut fidl::encoding::Encoder<'_, D>,
2090            offset: usize,
2091            depth: fidl::encoding::Depth,
2092        ) -> fidl::Result<()> {
2093            encoder.debug_check_bounds::<CentralDisconnectPeripheralRequest>(offset);
2094            // Zero out padding regions. There's no need to apply masks
2095            // because the unmasked parts will be overwritten by fields.
2096            // Write the fields.
2097            self.0.encode(encoder, offset + 0, depth)?;
2098            Ok(())
2099        }
2100    }
2101
2102    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2103        for CentralDisconnectPeripheralRequest
2104    {
2105        #[inline(always)]
2106        fn new_empty() -> Self {
2107            Self { identifier: fidl::new_empty!(fidl::encoding::BoundedString<16>, D) }
2108        }
2109
2110        #[inline]
2111        unsafe fn decode(
2112            &mut self,
2113            decoder: &mut fidl::encoding::Decoder<'_, D>,
2114            offset: usize,
2115            _depth: fidl::encoding::Depth,
2116        ) -> fidl::Result<()> {
2117            decoder.debug_check_bounds::<Self>(offset);
2118            // Verify that padding bytes are zero.
2119            fidl::decode!(
2120                fidl::encoding::BoundedString<16>,
2121                D,
2122                &mut self.identifier,
2123                decoder,
2124                offset + 0,
2125                _depth
2126            )?;
2127            Ok(())
2128        }
2129    }
2130
2131    impl fidl::encoding::ValueTypeMarker for CentralDisconnectPeripheralResponse {
2132        type Borrowed<'a> = &'a Self;
2133        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2134            value
2135        }
2136    }
2137
2138    unsafe impl fidl::encoding::TypeMarker for CentralDisconnectPeripheralResponse {
2139        type Owned = Self;
2140
2141        #[inline(always)]
2142        fn inline_align(_context: fidl::encoding::Context) -> usize {
2143            8
2144        }
2145
2146        #[inline(always)]
2147        fn inline_size(_context: fidl::encoding::Context) -> usize {
2148            8
2149        }
2150    }
2151
2152    unsafe impl<D: fidl::encoding::ResourceDialect>
2153        fidl::encoding::Encode<CentralDisconnectPeripheralResponse, D>
2154        for &CentralDisconnectPeripheralResponse
2155    {
2156        #[inline]
2157        unsafe fn encode(
2158            self,
2159            encoder: &mut fidl::encoding::Encoder<'_, D>,
2160            offset: usize,
2161            _depth: fidl::encoding::Depth,
2162        ) -> fidl::Result<()> {
2163            encoder.debug_check_bounds::<CentralDisconnectPeripheralResponse>(offset);
2164            // Delegate to tuple encoding.
2165            fidl::encoding::Encode::<CentralDisconnectPeripheralResponse, D>::encode(
2166                (
2167                    <fidl_fuchsia_bluetooth__common::Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
2168                ),
2169                encoder, offset, _depth
2170            )
2171        }
2172    }
2173    unsafe impl<
2174            D: fidl::encoding::ResourceDialect,
2175            T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::Status, D>,
2176        > fidl::encoding::Encode<CentralDisconnectPeripheralResponse, D> for (T0,)
2177    {
2178        #[inline]
2179        unsafe fn encode(
2180            self,
2181            encoder: &mut fidl::encoding::Encoder<'_, D>,
2182            offset: usize,
2183            depth: fidl::encoding::Depth,
2184        ) -> fidl::Result<()> {
2185            encoder.debug_check_bounds::<CentralDisconnectPeripheralResponse>(offset);
2186            // Zero out padding regions. There's no need to apply masks
2187            // because the unmasked parts will be overwritten by fields.
2188            // Write the fields.
2189            self.0.encode(encoder, offset + 0, depth)?;
2190            Ok(())
2191        }
2192    }
2193
2194    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2195        for CentralDisconnectPeripheralResponse
2196    {
2197        #[inline(always)]
2198        fn new_empty() -> Self {
2199            Self { status: fidl::new_empty!(fidl_fuchsia_bluetooth__common::Status, D) }
2200        }
2201
2202        #[inline]
2203        unsafe fn decode(
2204            &mut self,
2205            decoder: &mut fidl::encoding::Decoder<'_, D>,
2206            offset: usize,
2207            _depth: fidl::encoding::Depth,
2208        ) -> fidl::Result<()> {
2209            decoder.debug_check_bounds::<Self>(offset);
2210            // Verify that padding bytes are zero.
2211            fidl::decode!(
2212                fidl_fuchsia_bluetooth__common::Status,
2213                D,
2214                &mut self.status,
2215                decoder,
2216                offset + 0,
2217                _depth
2218            )?;
2219            Ok(())
2220        }
2221    }
2222
2223    impl fidl::encoding::ValueTypeMarker for CentralGetPeripheralRequest {
2224        type Borrowed<'a> = &'a Self;
2225        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2226            value
2227        }
2228    }
2229
2230    unsafe impl fidl::encoding::TypeMarker for CentralGetPeripheralRequest {
2231        type Owned = Self;
2232
2233        #[inline(always)]
2234        fn inline_align(_context: fidl::encoding::Context) -> usize {
2235            8
2236        }
2237
2238        #[inline(always)]
2239        fn inline_size(_context: fidl::encoding::Context) -> usize {
2240            16
2241        }
2242    }
2243
2244    unsafe impl<D: fidl::encoding::ResourceDialect>
2245        fidl::encoding::Encode<CentralGetPeripheralRequest, D> for &CentralGetPeripheralRequest
2246    {
2247        #[inline]
2248        unsafe fn encode(
2249            self,
2250            encoder: &mut fidl::encoding::Encoder<'_, D>,
2251            offset: usize,
2252            _depth: fidl::encoding::Depth,
2253        ) -> fidl::Result<()> {
2254            encoder.debug_check_bounds::<CentralGetPeripheralRequest>(offset);
2255            // Delegate to tuple encoding.
2256            fidl::encoding::Encode::<CentralGetPeripheralRequest, D>::encode(
2257                (<fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow(
2258                    &self.identifier,
2259                ),),
2260                encoder,
2261                offset,
2262                _depth,
2263            )
2264        }
2265    }
2266    unsafe impl<
2267            D: fidl::encoding::ResourceDialect,
2268            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<16>, D>,
2269        > fidl::encoding::Encode<CentralGetPeripheralRequest, D> for (T0,)
2270    {
2271        #[inline]
2272        unsafe fn encode(
2273            self,
2274            encoder: &mut fidl::encoding::Encoder<'_, D>,
2275            offset: usize,
2276            depth: fidl::encoding::Depth,
2277        ) -> fidl::Result<()> {
2278            encoder.debug_check_bounds::<CentralGetPeripheralRequest>(offset);
2279            // Zero out padding regions. There's no need to apply masks
2280            // because the unmasked parts will be overwritten by fields.
2281            // Write the fields.
2282            self.0.encode(encoder, offset + 0, depth)?;
2283            Ok(())
2284        }
2285    }
2286
2287    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2288        for CentralGetPeripheralRequest
2289    {
2290        #[inline(always)]
2291        fn new_empty() -> Self {
2292            Self { identifier: fidl::new_empty!(fidl::encoding::BoundedString<16>, D) }
2293        }
2294
2295        #[inline]
2296        unsafe fn decode(
2297            &mut self,
2298            decoder: &mut fidl::encoding::Decoder<'_, D>,
2299            offset: usize,
2300            _depth: fidl::encoding::Depth,
2301        ) -> fidl::Result<()> {
2302            decoder.debug_check_bounds::<Self>(offset);
2303            // Verify that padding bytes are zero.
2304            fidl::decode!(
2305                fidl::encoding::BoundedString<16>,
2306                D,
2307                &mut self.identifier,
2308                decoder,
2309                offset + 0,
2310                _depth
2311            )?;
2312            Ok(())
2313        }
2314    }
2315
2316    impl fidl::encoding::ValueTypeMarker for CentralGetPeripheralResponse {
2317        type Borrowed<'a> = &'a Self;
2318        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2319            value
2320        }
2321    }
2322
2323    unsafe impl fidl::encoding::TypeMarker for CentralGetPeripheralResponse {
2324        type Owned = Self;
2325
2326        #[inline(always)]
2327        fn inline_align(_context: fidl::encoding::Context) -> usize {
2328            8
2329        }
2330
2331        #[inline(always)]
2332        fn inline_size(_context: fidl::encoding::Context) -> usize {
2333            8
2334        }
2335    }
2336
2337    unsafe impl<D: fidl::encoding::ResourceDialect>
2338        fidl::encoding::Encode<CentralGetPeripheralResponse, D> for &CentralGetPeripheralResponse
2339    {
2340        #[inline]
2341        unsafe fn encode(
2342            self,
2343            encoder: &mut fidl::encoding::Encoder<'_, D>,
2344            offset: usize,
2345            _depth: fidl::encoding::Depth,
2346        ) -> fidl::Result<()> {
2347            encoder.debug_check_bounds::<CentralGetPeripheralResponse>(offset);
2348            // Delegate to tuple encoding.
2349            fidl::encoding::Encode::<CentralGetPeripheralResponse, D>::encode(
2350                (<fidl::encoding::Boxed<RemoteDevice> as fidl::encoding::ValueTypeMarker>::borrow(
2351                    &self.peripheral,
2352                ),),
2353                encoder,
2354                offset,
2355                _depth,
2356            )
2357        }
2358    }
2359    unsafe impl<
2360            D: fidl::encoding::ResourceDialect,
2361            T0: fidl::encoding::Encode<fidl::encoding::Boxed<RemoteDevice>, D>,
2362        > fidl::encoding::Encode<CentralGetPeripheralResponse, D> for (T0,)
2363    {
2364        #[inline]
2365        unsafe fn encode(
2366            self,
2367            encoder: &mut fidl::encoding::Encoder<'_, D>,
2368            offset: usize,
2369            depth: fidl::encoding::Depth,
2370        ) -> fidl::Result<()> {
2371            encoder.debug_check_bounds::<CentralGetPeripheralResponse>(offset);
2372            // Zero out padding regions. There's no need to apply masks
2373            // because the unmasked parts will be overwritten by fields.
2374            // Write the fields.
2375            self.0.encode(encoder, offset + 0, depth)?;
2376            Ok(())
2377        }
2378    }
2379
2380    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2381        for CentralGetPeripheralResponse
2382    {
2383        #[inline(always)]
2384        fn new_empty() -> Self {
2385            Self { peripheral: fidl::new_empty!(fidl::encoding::Boxed<RemoteDevice>, D) }
2386        }
2387
2388        #[inline]
2389        unsafe fn decode(
2390            &mut self,
2391            decoder: &mut fidl::encoding::Decoder<'_, D>,
2392            offset: usize,
2393            _depth: fidl::encoding::Depth,
2394        ) -> fidl::Result<()> {
2395            decoder.debug_check_bounds::<Self>(offset);
2396            // Verify that padding bytes are zero.
2397            fidl::decode!(
2398                fidl::encoding::Boxed<RemoteDevice>,
2399                D,
2400                &mut self.peripheral,
2401                decoder,
2402                offset + 0,
2403                _depth
2404            )?;
2405            Ok(())
2406        }
2407    }
2408
2409    impl fidl::encoding::ValueTypeMarker for CentralGetPeripheralsRequest {
2410        type Borrowed<'a> = &'a Self;
2411        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2412            value
2413        }
2414    }
2415
2416    unsafe impl fidl::encoding::TypeMarker for CentralGetPeripheralsRequest {
2417        type Owned = Self;
2418
2419        #[inline(always)]
2420        fn inline_align(_context: fidl::encoding::Context) -> usize {
2421            8
2422        }
2423
2424        #[inline(always)]
2425        fn inline_size(_context: fidl::encoding::Context) -> usize {
2426            16
2427        }
2428    }
2429
2430    unsafe impl<D: fidl::encoding::ResourceDialect>
2431        fidl::encoding::Encode<CentralGetPeripheralsRequest, D> for &CentralGetPeripheralsRequest
2432    {
2433        #[inline]
2434        unsafe fn encode(
2435            self,
2436            encoder: &mut fidl::encoding::Encoder<'_, D>,
2437            offset: usize,
2438            _depth: fidl::encoding::Depth,
2439        ) -> fidl::Result<()> {
2440            encoder.debug_check_bounds::<CentralGetPeripheralsRequest>(offset);
2441            // Delegate to tuple encoding.
2442            fidl::encoding::Encode::<CentralGetPeripheralsRequest, D>::encode(
2443                (<fidl::encoding::Optional<
2444                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
2445                > as fidl::encoding::ValueTypeMarker>::borrow(&self.service_uuids),),
2446                encoder,
2447                offset,
2448                _depth,
2449            )
2450        }
2451    }
2452    unsafe impl<
2453            D: fidl::encoding::ResourceDialect,
2454            T0: fidl::encoding::Encode<
2455                fidl::encoding::Optional<
2456                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
2457                >,
2458                D,
2459            >,
2460        > fidl::encoding::Encode<CentralGetPeripheralsRequest, D> for (T0,)
2461    {
2462        #[inline]
2463        unsafe fn encode(
2464            self,
2465            encoder: &mut fidl::encoding::Encoder<'_, D>,
2466            offset: usize,
2467            depth: fidl::encoding::Depth,
2468        ) -> fidl::Result<()> {
2469            encoder.debug_check_bounds::<CentralGetPeripheralsRequest>(offset);
2470            // Zero out padding regions. There's no need to apply masks
2471            // because the unmasked parts will be overwritten by fields.
2472            // Write the fields.
2473            self.0.encode(encoder, offset + 0, depth)?;
2474            Ok(())
2475        }
2476    }
2477
2478    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2479        for CentralGetPeripheralsRequest
2480    {
2481        #[inline(always)]
2482        fn new_empty() -> Self {
2483            Self {
2484                service_uuids: fidl::new_empty!(
2485                    fidl::encoding::Optional<
2486                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
2487                    >,
2488                    D
2489                ),
2490            }
2491        }
2492
2493        #[inline]
2494        unsafe fn decode(
2495            &mut self,
2496            decoder: &mut fidl::encoding::Decoder<'_, D>,
2497            offset: usize,
2498            _depth: fidl::encoding::Depth,
2499        ) -> fidl::Result<()> {
2500            decoder.debug_check_bounds::<Self>(offset);
2501            // Verify that padding bytes are zero.
2502            fidl::decode!(
2503                fidl::encoding::Optional<
2504                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
2505                >,
2506                D,
2507                &mut self.service_uuids,
2508                decoder,
2509                offset + 0,
2510                _depth
2511            )?;
2512            Ok(())
2513        }
2514    }
2515
2516    impl fidl::encoding::ValueTypeMarker for CentralGetPeripheralsResponse {
2517        type Borrowed<'a> = &'a Self;
2518        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2519            value
2520        }
2521    }
2522
2523    unsafe impl fidl::encoding::TypeMarker for CentralGetPeripheralsResponse {
2524        type Owned = Self;
2525
2526        #[inline(always)]
2527        fn inline_align(_context: fidl::encoding::Context) -> usize {
2528            8
2529        }
2530
2531        #[inline(always)]
2532        fn inline_size(_context: fidl::encoding::Context) -> usize {
2533            16
2534        }
2535    }
2536
2537    unsafe impl<D: fidl::encoding::ResourceDialect>
2538        fidl::encoding::Encode<CentralGetPeripheralsResponse, D>
2539        for &CentralGetPeripheralsResponse
2540    {
2541        #[inline]
2542        unsafe fn encode(
2543            self,
2544            encoder: &mut fidl::encoding::Encoder<'_, D>,
2545            offset: usize,
2546            _depth: fidl::encoding::Depth,
2547        ) -> fidl::Result<()> {
2548            encoder.debug_check_bounds::<CentralGetPeripheralsResponse>(offset);
2549            // Delegate to tuple encoding.
2550            fidl::encoding::Encode::<CentralGetPeripheralsResponse, D>::encode(
2551                (
2552                    <fidl::encoding::UnboundedVector<RemoteDevice> as fidl::encoding::ValueTypeMarker>::borrow(&self.peripherals),
2553                ),
2554                encoder, offset, _depth
2555            )
2556        }
2557    }
2558    unsafe impl<
2559            D: fidl::encoding::ResourceDialect,
2560            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<RemoteDevice>, D>,
2561        > fidl::encoding::Encode<CentralGetPeripheralsResponse, D> for (T0,)
2562    {
2563        #[inline]
2564        unsafe fn encode(
2565            self,
2566            encoder: &mut fidl::encoding::Encoder<'_, D>,
2567            offset: usize,
2568            depth: fidl::encoding::Depth,
2569        ) -> fidl::Result<()> {
2570            encoder.debug_check_bounds::<CentralGetPeripheralsResponse>(offset);
2571            // Zero out padding regions. There's no need to apply masks
2572            // because the unmasked parts will be overwritten by fields.
2573            // Write the fields.
2574            self.0.encode(encoder, offset + 0, depth)?;
2575            Ok(())
2576        }
2577    }
2578
2579    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2580        for CentralGetPeripheralsResponse
2581    {
2582        #[inline(always)]
2583        fn new_empty() -> Self {
2584            Self { peripherals: fidl::new_empty!(fidl::encoding::UnboundedVector<RemoteDevice>, D) }
2585        }
2586
2587        #[inline]
2588        unsafe fn decode(
2589            &mut self,
2590            decoder: &mut fidl::encoding::Decoder<'_, D>,
2591            offset: usize,
2592            _depth: fidl::encoding::Depth,
2593        ) -> fidl::Result<()> {
2594            decoder.debug_check_bounds::<Self>(offset);
2595            // Verify that padding bytes are zero.
2596            fidl::decode!(
2597                fidl::encoding::UnboundedVector<RemoteDevice>,
2598                D,
2599                &mut self.peripherals,
2600                decoder,
2601                offset + 0,
2602                _depth
2603            )?;
2604            Ok(())
2605        }
2606    }
2607
2608    impl fidl::encoding::ValueTypeMarker for CentralOnDeviceDiscoveredRequest {
2609        type Borrowed<'a> = &'a Self;
2610        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2611            value
2612        }
2613    }
2614
2615    unsafe impl fidl::encoding::TypeMarker for CentralOnDeviceDiscoveredRequest {
2616        type Owned = Self;
2617
2618        #[inline(always)]
2619        fn inline_align(_context: fidl::encoding::Context) -> usize {
2620            8
2621        }
2622
2623        #[inline(always)]
2624        fn inline_size(_context: fidl::encoding::Context) -> usize {
2625            40
2626        }
2627    }
2628
2629    unsafe impl<D: fidl::encoding::ResourceDialect>
2630        fidl::encoding::Encode<CentralOnDeviceDiscoveredRequest, D>
2631        for &CentralOnDeviceDiscoveredRequest
2632    {
2633        #[inline]
2634        unsafe fn encode(
2635            self,
2636            encoder: &mut fidl::encoding::Encoder<'_, D>,
2637            offset: usize,
2638            _depth: fidl::encoding::Depth,
2639        ) -> fidl::Result<()> {
2640            encoder.debug_check_bounds::<CentralOnDeviceDiscoveredRequest>(offset);
2641            // Delegate to tuple encoding.
2642            fidl::encoding::Encode::<CentralOnDeviceDiscoveredRequest, D>::encode(
2643                (<RemoteDevice as fidl::encoding::ValueTypeMarker>::borrow(&self.device),),
2644                encoder,
2645                offset,
2646                _depth,
2647            )
2648        }
2649    }
2650    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<RemoteDevice, D>>
2651        fidl::encoding::Encode<CentralOnDeviceDiscoveredRequest, D> for (T0,)
2652    {
2653        #[inline]
2654        unsafe fn encode(
2655            self,
2656            encoder: &mut fidl::encoding::Encoder<'_, D>,
2657            offset: usize,
2658            depth: fidl::encoding::Depth,
2659        ) -> fidl::Result<()> {
2660            encoder.debug_check_bounds::<CentralOnDeviceDiscoveredRequest>(offset);
2661            // Zero out padding regions. There's no need to apply masks
2662            // because the unmasked parts will be overwritten by fields.
2663            // Write the fields.
2664            self.0.encode(encoder, offset + 0, depth)?;
2665            Ok(())
2666        }
2667    }
2668
2669    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2670        for CentralOnDeviceDiscoveredRequest
2671    {
2672        #[inline(always)]
2673        fn new_empty() -> Self {
2674            Self { device: fidl::new_empty!(RemoteDevice, D) }
2675        }
2676
2677        #[inline]
2678        unsafe fn decode(
2679            &mut self,
2680            decoder: &mut fidl::encoding::Decoder<'_, D>,
2681            offset: usize,
2682            _depth: fidl::encoding::Depth,
2683        ) -> fidl::Result<()> {
2684            decoder.debug_check_bounds::<Self>(offset);
2685            // Verify that padding bytes are zero.
2686            fidl::decode!(RemoteDevice, D, &mut self.device, decoder, offset + 0, _depth)?;
2687            Ok(())
2688        }
2689    }
2690
2691    impl fidl::encoding::ValueTypeMarker for CentralOnPeripheralDisconnectedRequest {
2692        type Borrowed<'a> = &'a Self;
2693        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2694            value
2695        }
2696    }
2697
2698    unsafe impl fidl::encoding::TypeMarker for CentralOnPeripheralDisconnectedRequest {
2699        type Owned = Self;
2700
2701        #[inline(always)]
2702        fn inline_align(_context: fidl::encoding::Context) -> usize {
2703            8
2704        }
2705
2706        #[inline(always)]
2707        fn inline_size(_context: fidl::encoding::Context) -> usize {
2708            16
2709        }
2710    }
2711
2712    unsafe impl<D: fidl::encoding::ResourceDialect>
2713        fidl::encoding::Encode<CentralOnPeripheralDisconnectedRequest, D>
2714        for &CentralOnPeripheralDisconnectedRequest
2715    {
2716        #[inline]
2717        unsafe fn encode(
2718            self,
2719            encoder: &mut fidl::encoding::Encoder<'_, D>,
2720            offset: usize,
2721            _depth: fidl::encoding::Depth,
2722        ) -> fidl::Result<()> {
2723            encoder.debug_check_bounds::<CentralOnPeripheralDisconnectedRequest>(offset);
2724            // Delegate to tuple encoding.
2725            fidl::encoding::Encode::<CentralOnPeripheralDisconnectedRequest, D>::encode(
2726                (<fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow(
2727                    &self.identifier,
2728                ),),
2729                encoder,
2730                offset,
2731                _depth,
2732            )
2733        }
2734    }
2735    unsafe impl<
2736            D: fidl::encoding::ResourceDialect,
2737            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<16>, D>,
2738        > fidl::encoding::Encode<CentralOnPeripheralDisconnectedRequest, D> for (T0,)
2739    {
2740        #[inline]
2741        unsafe fn encode(
2742            self,
2743            encoder: &mut fidl::encoding::Encoder<'_, D>,
2744            offset: usize,
2745            depth: fidl::encoding::Depth,
2746        ) -> fidl::Result<()> {
2747            encoder.debug_check_bounds::<CentralOnPeripheralDisconnectedRequest>(offset);
2748            // Zero out padding regions. There's no need to apply masks
2749            // because the unmasked parts will be overwritten by fields.
2750            // Write the fields.
2751            self.0.encode(encoder, offset + 0, depth)?;
2752            Ok(())
2753        }
2754    }
2755
2756    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2757        for CentralOnPeripheralDisconnectedRequest
2758    {
2759        #[inline(always)]
2760        fn new_empty() -> Self {
2761            Self { identifier: fidl::new_empty!(fidl::encoding::BoundedString<16>, D) }
2762        }
2763
2764        #[inline]
2765        unsafe fn decode(
2766            &mut self,
2767            decoder: &mut fidl::encoding::Decoder<'_, D>,
2768            offset: usize,
2769            _depth: fidl::encoding::Depth,
2770        ) -> fidl::Result<()> {
2771            decoder.debug_check_bounds::<Self>(offset);
2772            // Verify that padding bytes are zero.
2773            fidl::decode!(
2774                fidl::encoding::BoundedString<16>,
2775                D,
2776                &mut self.identifier,
2777                decoder,
2778                offset + 0,
2779                _depth
2780            )?;
2781            Ok(())
2782        }
2783    }
2784
2785    impl fidl::encoding::ValueTypeMarker for CentralOnScanStateChangedRequest {
2786        type Borrowed<'a> = &'a Self;
2787        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2788            value
2789        }
2790    }
2791
2792    unsafe impl fidl::encoding::TypeMarker for CentralOnScanStateChangedRequest {
2793        type Owned = Self;
2794
2795        #[inline(always)]
2796        fn inline_align(_context: fidl::encoding::Context) -> usize {
2797            1
2798        }
2799
2800        #[inline(always)]
2801        fn inline_size(_context: fidl::encoding::Context) -> usize {
2802            1
2803        }
2804    }
2805
2806    unsafe impl<D: fidl::encoding::ResourceDialect>
2807        fidl::encoding::Encode<CentralOnScanStateChangedRequest, D>
2808        for &CentralOnScanStateChangedRequest
2809    {
2810        #[inline]
2811        unsafe fn encode(
2812            self,
2813            encoder: &mut fidl::encoding::Encoder<'_, D>,
2814            offset: usize,
2815            _depth: fidl::encoding::Depth,
2816        ) -> fidl::Result<()> {
2817            encoder.debug_check_bounds::<CentralOnScanStateChangedRequest>(offset);
2818            // Delegate to tuple encoding.
2819            fidl::encoding::Encode::<CentralOnScanStateChangedRequest, D>::encode(
2820                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.scanning),),
2821                encoder,
2822                offset,
2823                _depth,
2824            )
2825        }
2826    }
2827    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
2828        fidl::encoding::Encode<CentralOnScanStateChangedRequest, D> for (T0,)
2829    {
2830        #[inline]
2831        unsafe fn encode(
2832            self,
2833            encoder: &mut fidl::encoding::Encoder<'_, D>,
2834            offset: usize,
2835            depth: fidl::encoding::Depth,
2836        ) -> fidl::Result<()> {
2837            encoder.debug_check_bounds::<CentralOnScanStateChangedRequest>(offset);
2838            // Zero out padding regions. There's no need to apply masks
2839            // because the unmasked parts will be overwritten by fields.
2840            // Write the fields.
2841            self.0.encode(encoder, offset + 0, depth)?;
2842            Ok(())
2843        }
2844    }
2845
2846    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2847        for CentralOnScanStateChangedRequest
2848    {
2849        #[inline(always)]
2850        fn new_empty() -> Self {
2851            Self { scanning: fidl::new_empty!(bool, D) }
2852        }
2853
2854        #[inline]
2855        unsafe fn decode(
2856            &mut self,
2857            decoder: &mut fidl::encoding::Decoder<'_, D>,
2858            offset: usize,
2859            _depth: fidl::encoding::Depth,
2860        ) -> fidl::Result<()> {
2861            decoder.debug_check_bounds::<Self>(offset);
2862            // Verify that padding bytes are zero.
2863            fidl::decode!(bool, D, &mut self.scanning, decoder, offset + 0, _depth)?;
2864            Ok(())
2865        }
2866    }
2867
2868    impl fidl::encoding::ValueTypeMarker for CentralStartScanRequest {
2869        type Borrowed<'a> = &'a Self;
2870        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2871            value
2872        }
2873    }
2874
2875    unsafe impl fidl::encoding::TypeMarker for CentralStartScanRequest {
2876        type Owned = Self;
2877
2878        #[inline(always)]
2879        fn inline_align(_context: fidl::encoding::Context) -> usize {
2880            8
2881        }
2882
2883        #[inline(always)]
2884        fn inline_size(_context: fidl::encoding::Context) -> usize {
2885            8
2886        }
2887    }
2888
2889    unsafe impl<D: fidl::encoding::ResourceDialect>
2890        fidl::encoding::Encode<CentralStartScanRequest, D> for &CentralStartScanRequest
2891    {
2892        #[inline]
2893        unsafe fn encode(
2894            self,
2895            encoder: &mut fidl::encoding::Encoder<'_, D>,
2896            offset: usize,
2897            _depth: fidl::encoding::Depth,
2898        ) -> fidl::Result<()> {
2899            encoder.debug_check_bounds::<CentralStartScanRequest>(offset);
2900            // Delegate to tuple encoding.
2901            fidl::encoding::Encode::<CentralStartScanRequest, D>::encode(
2902                (<fidl::encoding::Boxed<ScanFilter> as fidl::encoding::ValueTypeMarker>::borrow(
2903                    &self.filter,
2904                ),),
2905                encoder,
2906                offset,
2907                _depth,
2908            )
2909        }
2910    }
2911    unsafe impl<
2912            D: fidl::encoding::ResourceDialect,
2913            T0: fidl::encoding::Encode<fidl::encoding::Boxed<ScanFilter>, D>,
2914        > fidl::encoding::Encode<CentralStartScanRequest, D> for (T0,)
2915    {
2916        #[inline]
2917        unsafe fn encode(
2918            self,
2919            encoder: &mut fidl::encoding::Encoder<'_, D>,
2920            offset: usize,
2921            depth: fidl::encoding::Depth,
2922        ) -> fidl::Result<()> {
2923            encoder.debug_check_bounds::<CentralStartScanRequest>(offset);
2924            // Zero out padding regions. There's no need to apply masks
2925            // because the unmasked parts will be overwritten by fields.
2926            // Write the fields.
2927            self.0.encode(encoder, offset + 0, depth)?;
2928            Ok(())
2929        }
2930    }
2931
2932    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2933        for CentralStartScanRequest
2934    {
2935        #[inline(always)]
2936        fn new_empty() -> Self {
2937            Self { filter: fidl::new_empty!(fidl::encoding::Boxed<ScanFilter>, D) }
2938        }
2939
2940        #[inline]
2941        unsafe fn decode(
2942            &mut self,
2943            decoder: &mut fidl::encoding::Decoder<'_, D>,
2944            offset: usize,
2945            _depth: fidl::encoding::Depth,
2946        ) -> fidl::Result<()> {
2947            decoder.debug_check_bounds::<Self>(offset);
2948            // Verify that padding bytes are zero.
2949            fidl::decode!(
2950                fidl::encoding::Boxed<ScanFilter>,
2951                D,
2952                &mut self.filter,
2953                decoder,
2954                offset + 0,
2955                _depth
2956            )?;
2957            Ok(())
2958        }
2959    }
2960
2961    impl fidl::encoding::ValueTypeMarker for CentralStartScanResponse {
2962        type Borrowed<'a> = &'a Self;
2963        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2964            value
2965        }
2966    }
2967
2968    unsafe impl fidl::encoding::TypeMarker for CentralStartScanResponse {
2969        type Owned = Self;
2970
2971        #[inline(always)]
2972        fn inline_align(_context: fidl::encoding::Context) -> usize {
2973            8
2974        }
2975
2976        #[inline(always)]
2977        fn inline_size(_context: fidl::encoding::Context) -> usize {
2978            8
2979        }
2980    }
2981
2982    unsafe impl<D: fidl::encoding::ResourceDialect>
2983        fidl::encoding::Encode<CentralStartScanResponse, D> for &CentralStartScanResponse
2984    {
2985        #[inline]
2986        unsafe fn encode(
2987            self,
2988            encoder: &mut fidl::encoding::Encoder<'_, D>,
2989            offset: usize,
2990            _depth: fidl::encoding::Depth,
2991        ) -> fidl::Result<()> {
2992            encoder.debug_check_bounds::<CentralStartScanResponse>(offset);
2993            // Delegate to tuple encoding.
2994            fidl::encoding::Encode::<CentralStartScanResponse, D>::encode(
2995                (
2996                    <fidl_fuchsia_bluetooth__common::Status as fidl::encoding::ValueTypeMarker>::borrow(&self.status),
2997                ),
2998                encoder, offset, _depth
2999            )
3000        }
3001    }
3002    unsafe impl<
3003            D: fidl::encoding::ResourceDialect,
3004            T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::Status, D>,
3005        > fidl::encoding::Encode<CentralStartScanResponse, D> for (T0,)
3006    {
3007        #[inline]
3008        unsafe fn encode(
3009            self,
3010            encoder: &mut fidl::encoding::Encoder<'_, D>,
3011            offset: usize,
3012            depth: fidl::encoding::Depth,
3013        ) -> fidl::Result<()> {
3014            encoder.debug_check_bounds::<CentralStartScanResponse>(offset);
3015            // Zero out padding regions. There's no need to apply masks
3016            // because the unmasked parts will be overwritten by fields.
3017            // Write the fields.
3018            self.0.encode(encoder, offset + 0, depth)?;
3019            Ok(())
3020        }
3021    }
3022
3023    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3024        for CentralStartScanResponse
3025    {
3026        #[inline(always)]
3027        fn new_empty() -> Self {
3028            Self { status: fidl::new_empty!(fidl_fuchsia_bluetooth__common::Status, D) }
3029        }
3030
3031        #[inline]
3032        unsafe fn decode(
3033            &mut self,
3034            decoder: &mut fidl::encoding::Decoder<'_, D>,
3035            offset: usize,
3036            _depth: fidl::encoding::Depth,
3037        ) -> fidl::Result<()> {
3038            decoder.debug_check_bounds::<Self>(offset);
3039            // Verify that padding bytes are zero.
3040            fidl::decode!(
3041                fidl_fuchsia_bluetooth__common::Status,
3042                D,
3043                &mut self.status,
3044                decoder,
3045                offset + 0,
3046                _depth
3047            )?;
3048            Ok(())
3049        }
3050    }
3051
3052    impl fidl::encoding::ValueTypeMarker for ManufacturerData {
3053        type Borrowed<'a> = &'a Self;
3054        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3055            value
3056        }
3057    }
3058
3059    unsafe impl fidl::encoding::TypeMarker for ManufacturerData {
3060        type Owned = Self;
3061
3062        #[inline(always)]
3063        fn inline_align(_context: fidl::encoding::Context) -> usize {
3064            8
3065        }
3066
3067        #[inline(always)]
3068        fn inline_size(_context: fidl::encoding::Context) -> usize {
3069            24
3070        }
3071    }
3072
3073    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ManufacturerData, D>
3074        for &ManufacturerData
3075    {
3076        #[inline]
3077        unsafe fn encode(
3078            self,
3079            encoder: &mut fidl::encoding::Encoder<'_, D>,
3080            offset: usize,
3081            _depth: fidl::encoding::Depth,
3082        ) -> fidl::Result<()> {
3083            encoder.debug_check_bounds::<ManufacturerData>(offset);
3084            // Delegate to tuple encoding.
3085            fidl::encoding::Encode::<ManufacturerData, D>::encode(
3086                (
3087                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.company_id),
3088                    <fidl::encoding::Vector<u8, 252> as fidl::encoding::ValueTypeMarker>::borrow(
3089                        &self.data,
3090                    ),
3091                ),
3092                encoder,
3093                offset,
3094                _depth,
3095            )
3096        }
3097    }
3098    unsafe impl<
3099            D: fidl::encoding::ResourceDialect,
3100            T0: fidl::encoding::Encode<u16, D>,
3101            T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 252>, D>,
3102        > fidl::encoding::Encode<ManufacturerData, D> for (T0, T1)
3103    {
3104        #[inline]
3105        unsafe fn encode(
3106            self,
3107            encoder: &mut fidl::encoding::Encoder<'_, D>,
3108            offset: usize,
3109            depth: fidl::encoding::Depth,
3110        ) -> fidl::Result<()> {
3111            encoder.debug_check_bounds::<ManufacturerData>(offset);
3112            // Zero out padding regions. There's no need to apply masks
3113            // because the unmasked parts will be overwritten by fields.
3114            unsafe {
3115                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
3116                (ptr as *mut u64).write_unaligned(0);
3117            }
3118            // Write the fields.
3119            self.0.encode(encoder, offset + 0, depth)?;
3120            self.1.encode(encoder, offset + 8, depth)?;
3121            Ok(())
3122        }
3123    }
3124
3125    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ManufacturerData {
3126        #[inline(always)]
3127        fn new_empty() -> Self {
3128            Self {
3129                company_id: fidl::new_empty!(u16, D),
3130                data: fidl::new_empty!(fidl::encoding::Vector<u8, 252>, D),
3131            }
3132        }
3133
3134        #[inline]
3135        unsafe fn decode(
3136            &mut self,
3137            decoder: &mut fidl::encoding::Decoder<'_, D>,
3138            offset: usize,
3139            _depth: fidl::encoding::Depth,
3140        ) -> fidl::Result<()> {
3141            decoder.debug_check_bounds::<Self>(offset);
3142            // Verify that padding bytes are zero.
3143            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
3144            let padval = unsafe { (ptr as *const u64).read_unaligned() };
3145            let mask = 0xffffffffffff0000u64;
3146            let maskedval = padval & mask;
3147            if maskedval != 0 {
3148                return Err(fidl::Error::NonZeroPadding {
3149                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
3150                });
3151            }
3152            fidl::decode!(u16, D, &mut self.company_id, decoder, offset + 0, _depth)?;
3153            fidl::decode!(fidl::encoding::Vector<u8, 252>, D, &mut self.data, decoder, offset + 8, _depth)?;
3154            Ok(())
3155        }
3156    }
3157
3158    impl fidl::encoding::ValueTypeMarker for ManufacturerSpecificDataEntry {
3159        type Borrowed<'a> = &'a Self;
3160        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3161            value
3162        }
3163    }
3164
3165    unsafe impl fidl::encoding::TypeMarker for ManufacturerSpecificDataEntry {
3166        type Owned = Self;
3167
3168        #[inline(always)]
3169        fn inline_align(_context: fidl::encoding::Context) -> usize {
3170            8
3171        }
3172
3173        #[inline(always)]
3174        fn inline_size(_context: fidl::encoding::Context) -> usize {
3175            24
3176        }
3177    }
3178
3179    unsafe impl<D: fidl::encoding::ResourceDialect>
3180        fidl::encoding::Encode<ManufacturerSpecificDataEntry, D>
3181        for &ManufacturerSpecificDataEntry
3182    {
3183        #[inline]
3184        unsafe fn encode(
3185            self,
3186            encoder: &mut fidl::encoding::Encoder<'_, D>,
3187            offset: usize,
3188            _depth: fidl::encoding::Depth,
3189        ) -> fidl::Result<()> {
3190            encoder.debug_check_bounds::<ManufacturerSpecificDataEntry>(offset);
3191            // Delegate to tuple encoding.
3192            fidl::encoding::Encode::<ManufacturerSpecificDataEntry, D>::encode(
3193                (
3194                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(&self.company_id),
3195                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
3196                ),
3197                encoder, offset, _depth
3198            )
3199        }
3200    }
3201    unsafe impl<
3202            D: fidl::encoding::ResourceDialect,
3203            T0: fidl::encoding::Encode<u16, D>,
3204            T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
3205        > fidl::encoding::Encode<ManufacturerSpecificDataEntry, D> for (T0, T1)
3206    {
3207        #[inline]
3208        unsafe fn encode(
3209            self,
3210            encoder: &mut fidl::encoding::Encoder<'_, D>,
3211            offset: usize,
3212            depth: fidl::encoding::Depth,
3213        ) -> fidl::Result<()> {
3214            encoder.debug_check_bounds::<ManufacturerSpecificDataEntry>(offset);
3215            // Zero out padding regions. There's no need to apply masks
3216            // because the unmasked parts will be overwritten by fields.
3217            unsafe {
3218                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
3219                (ptr as *mut u64).write_unaligned(0);
3220            }
3221            // Write the fields.
3222            self.0.encode(encoder, offset + 0, depth)?;
3223            self.1.encode(encoder, offset + 8, depth)?;
3224            Ok(())
3225        }
3226    }
3227
3228    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3229        for ManufacturerSpecificDataEntry
3230    {
3231        #[inline(always)]
3232        fn new_empty() -> Self {
3233            Self {
3234                company_id: fidl::new_empty!(u16, D),
3235                data: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
3236            }
3237        }
3238
3239        #[inline]
3240        unsafe fn decode(
3241            &mut self,
3242            decoder: &mut fidl::encoding::Decoder<'_, D>,
3243            offset: usize,
3244            _depth: fidl::encoding::Depth,
3245        ) -> fidl::Result<()> {
3246            decoder.debug_check_bounds::<Self>(offset);
3247            // Verify that padding bytes are zero.
3248            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
3249            let padval = unsafe { (ptr as *const u64).read_unaligned() };
3250            let mask = 0xffffffffffff0000u64;
3251            let maskedval = padval & mask;
3252            if maskedval != 0 {
3253                return Err(fidl::Error::NonZeroPadding {
3254                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
3255                });
3256            }
3257            fidl::decode!(u16, D, &mut self.company_id, decoder, offset + 0, _depth)?;
3258            fidl::decode!(
3259                fidl::encoding::UnboundedVector<u8>,
3260                D,
3261                &mut self.data,
3262                decoder,
3263                offset + 8,
3264                _depth
3265            )?;
3266            Ok(())
3267        }
3268    }
3269
3270    impl fidl::encoding::ValueTypeMarker for RemoteDevice {
3271        type Borrowed<'a> = &'a Self;
3272        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3273            value
3274        }
3275    }
3276
3277    unsafe impl fidl::encoding::TypeMarker for RemoteDevice {
3278        type Owned = Self;
3279
3280        #[inline(always)]
3281        fn inline_align(_context: fidl::encoding::Context) -> usize {
3282            8
3283        }
3284
3285        #[inline(always)]
3286        fn inline_size(_context: fidl::encoding::Context) -> usize {
3287            40
3288        }
3289    }
3290
3291    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RemoteDevice, D>
3292        for &RemoteDevice
3293    {
3294        #[inline]
3295        unsafe fn encode(
3296            self,
3297            encoder: &mut fidl::encoding::Encoder<'_, D>,
3298            offset: usize,
3299            _depth: fidl::encoding::Depth,
3300        ) -> fidl::Result<()> {
3301            encoder.debug_check_bounds::<RemoteDevice>(offset);
3302            // Delegate to tuple encoding.
3303            fidl::encoding::Encode::<RemoteDevice, D>::encode(
3304                (
3305                    <fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow(&self.identifier),
3306                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.connectable),
3307                    <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8> as fidl::encoding::ValueTypeMarker>::borrow(&self.rssi),
3308                    <fidl::encoding::Boxed<AdvertisingDataDeprecated> as fidl::encoding::ValueTypeMarker>::borrow(&self.advertising_data),
3309                ),
3310                encoder, offset, _depth
3311            )
3312        }
3313    }
3314    unsafe impl<
3315            D: fidl::encoding::ResourceDialect,
3316            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<16>, D>,
3317            T1: fidl::encoding::Encode<bool, D>,
3318            T2: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>, D>,
3319            T3: fidl::encoding::Encode<fidl::encoding::Boxed<AdvertisingDataDeprecated>, D>,
3320        > fidl::encoding::Encode<RemoteDevice, D> for (T0, T1, T2, T3)
3321    {
3322        #[inline]
3323        unsafe fn encode(
3324            self,
3325            encoder: &mut fidl::encoding::Encoder<'_, D>,
3326            offset: usize,
3327            depth: fidl::encoding::Depth,
3328        ) -> fidl::Result<()> {
3329            encoder.debug_check_bounds::<RemoteDevice>(offset);
3330            // Zero out padding regions. There's no need to apply masks
3331            // because the unmasked parts will be overwritten by fields.
3332            unsafe {
3333                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
3334                (ptr as *mut u64).write_unaligned(0);
3335            }
3336            // Write the fields.
3337            self.0.encode(encoder, offset + 0, depth)?;
3338            self.1.encode(encoder, offset + 16, depth)?;
3339            self.2.encode(encoder, offset + 24, depth)?;
3340            self.3.encode(encoder, offset + 32, depth)?;
3341            Ok(())
3342        }
3343    }
3344
3345    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RemoteDevice {
3346        #[inline(always)]
3347        fn new_empty() -> Self {
3348            Self {
3349                identifier: fidl::new_empty!(fidl::encoding::BoundedString<16>, D),
3350                connectable: fidl::new_empty!(bool, D),
3351                rssi: fidl::new_empty!(
3352                    fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
3353                    D
3354                ),
3355                advertising_data: fidl::new_empty!(
3356                    fidl::encoding::Boxed<AdvertisingDataDeprecated>,
3357                    D
3358                ),
3359            }
3360        }
3361
3362        #[inline]
3363        unsafe fn decode(
3364            &mut self,
3365            decoder: &mut fidl::encoding::Decoder<'_, D>,
3366            offset: usize,
3367            _depth: fidl::encoding::Depth,
3368        ) -> fidl::Result<()> {
3369            decoder.debug_check_bounds::<Self>(offset);
3370            // Verify that padding bytes are zero.
3371            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
3372            let padval = unsafe { (ptr as *const u64).read_unaligned() };
3373            let mask = 0xffffffffffffff00u64;
3374            let maskedval = padval & mask;
3375            if maskedval != 0 {
3376                return Err(fidl::Error::NonZeroPadding {
3377                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
3378                });
3379            }
3380            fidl::decode!(
3381                fidl::encoding::BoundedString<16>,
3382                D,
3383                &mut self.identifier,
3384                decoder,
3385                offset + 0,
3386                _depth
3387            )?;
3388            fidl::decode!(bool, D, &mut self.connectable, decoder, offset + 16, _depth)?;
3389            fidl::decode!(
3390                fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
3391                D,
3392                &mut self.rssi,
3393                decoder,
3394                offset + 24,
3395                _depth
3396            )?;
3397            fidl::decode!(
3398                fidl::encoding::Boxed<AdvertisingDataDeprecated>,
3399                D,
3400                &mut self.advertising_data,
3401                decoder,
3402                offset + 32,
3403                _depth
3404            )?;
3405            Ok(())
3406        }
3407    }
3408
3409    impl fidl::encoding::ValueTypeMarker for ScanFilter {
3410        type Borrowed<'a> = &'a Self;
3411        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3412            value
3413        }
3414    }
3415
3416    unsafe impl fidl::encoding::TypeMarker for ScanFilter {
3417        type Owned = Self;
3418
3419        #[inline(always)]
3420        fn inline_align(_context: fidl::encoding::Context) -> usize {
3421            8
3422        }
3423
3424        #[inline(always)]
3425        fn inline_size(_context: fidl::encoding::Context) -> usize {
3426            72
3427        }
3428    }
3429
3430    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ScanFilter, D>
3431        for &ScanFilter
3432    {
3433        #[inline]
3434        unsafe fn encode(
3435            self,
3436            encoder: &mut fidl::encoding::Encoder<'_, D>,
3437            offset: usize,
3438            _depth: fidl::encoding::Depth,
3439        ) -> fidl::Result<()> {
3440            encoder.debug_check_bounds::<ScanFilter>(offset);
3441            // Delegate to tuple encoding.
3442            fidl::encoding::Encode::<ScanFilter, D>::encode(
3443                (
3444                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.service_uuids),
3445                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.service_data_uuids),
3446                    <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16> as fidl::encoding::ValueTypeMarker>::borrow(&self.manufacturer_identifier),
3447                    <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Bool> as fidl::encoding::ValueTypeMarker>::borrow(&self.connectable),
3448                    <fidl::encoding::Optional<fidl::encoding::BoundedString<248>> as fidl::encoding::ValueTypeMarker>::borrow(&self.name_substring),
3449                    <fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8> as fidl::encoding::ValueTypeMarker>::borrow(&self.max_path_loss),
3450                ),
3451                encoder, offset, _depth
3452            )
3453        }
3454    }
3455    unsafe impl<
3456            D: fidl::encoding::ResourceDialect,
3457            T0: fidl::encoding::Encode<
3458                fidl::encoding::Optional<
3459                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3460                >,
3461                D,
3462            >,
3463            T1: fidl::encoding::Encode<
3464                fidl::encoding::Optional<
3465                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3466                >,
3467                D,
3468            >,
3469            T2: fidl::encoding::Encode<
3470                fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
3471                D,
3472            >,
3473            T3: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Bool>, D>,
3474            T4: fidl::encoding::Encode<fidl::encoding::Optional<fidl::encoding::BoundedString<248>>, D>,
3475            T5: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>, D>,
3476        > fidl::encoding::Encode<ScanFilter, D> for (T0, T1, T2, T3, T4, T5)
3477    {
3478        #[inline]
3479        unsafe fn encode(
3480            self,
3481            encoder: &mut fidl::encoding::Encoder<'_, D>,
3482            offset: usize,
3483            depth: fidl::encoding::Depth,
3484        ) -> fidl::Result<()> {
3485            encoder.debug_check_bounds::<ScanFilter>(offset);
3486            // Zero out padding regions. There's no need to apply masks
3487            // because the unmasked parts will be overwritten by fields.
3488            // Write the fields.
3489            self.0.encode(encoder, offset + 0, depth)?;
3490            self.1.encode(encoder, offset + 16, depth)?;
3491            self.2.encode(encoder, offset + 32, depth)?;
3492            self.3.encode(encoder, offset + 40, depth)?;
3493            self.4.encode(encoder, offset + 48, depth)?;
3494            self.5.encode(encoder, offset + 64, depth)?;
3495            Ok(())
3496        }
3497    }
3498
3499    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanFilter {
3500        #[inline(always)]
3501        fn new_empty() -> Self {
3502            Self {
3503                service_uuids: fidl::new_empty!(
3504                    fidl::encoding::Optional<
3505                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3506                    >,
3507                    D
3508                ),
3509                service_data_uuids: fidl::new_empty!(
3510                    fidl::encoding::Optional<
3511                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3512                    >,
3513                    D
3514                ),
3515                manufacturer_identifier: fidl::new_empty!(
3516                    fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
3517                    D
3518                ),
3519                connectable: fidl::new_empty!(
3520                    fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Bool>,
3521                    D
3522                ),
3523                name_substring: fidl::new_empty!(
3524                    fidl::encoding::Optional<fidl::encoding::BoundedString<248>>,
3525                    D
3526                ),
3527                max_path_loss: fidl::new_empty!(
3528                    fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
3529                    D
3530                ),
3531            }
3532        }
3533
3534        #[inline]
3535        unsafe fn decode(
3536            &mut self,
3537            decoder: &mut fidl::encoding::Decoder<'_, D>,
3538            offset: usize,
3539            _depth: fidl::encoding::Depth,
3540        ) -> fidl::Result<()> {
3541            decoder.debug_check_bounds::<Self>(offset);
3542            // Verify that padding bytes are zero.
3543            fidl::decode!(
3544                fidl::encoding::Optional<
3545                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3546                >,
3547                D,
3548                &mut self.service_uuids,
3549                decoder,
3550                offset + 0,
3551                _depth
3552            )?;
3553            fidl::decode!(
3554                fidl::encoding::Optional<
3555                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<36>>,
3556                >,
3557                D,
3558                &mut self.service_data_uuids,
3559                decoder,
3560                offset + 16,
3561                _depth
3562            )?;
3563            fidl::decode!(
3564                fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::UInt16>,
3565                D,
3566                &mut self.manufacturer_identifier,
3567                decoder,
3568                offset + 32,
3569                _depth
3570            )?;
3571            fidl::decode!(
3572                fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Bool>,
3573                D,
3574                &mut self.connectable,
3575                decoder,
3576                offset + 40,
3577                _depth
3578            )?;
3579            fidl::decode!(
3580                fidl::encoding::Optional<fidl::encoding::BoundedString<248>>,
3581                D,
3582                &mut self.name_substring,
3583                decoder,
3584                offset + 48,
3585                _depth
3586            )?;
3587            fidl::decode!(
3588                fidl::encoding::Boxed<fidl_fuchsia_bluetooth__common::Int8>,
3589                D,
3590                &mut self.max_path_loss,
3591                decoder,
3592                offset + 64,
3593                _depth
3594            )?;
3595            Ok(())
3596        }
3597    }
3598
3599    impl fidl::encoding::ValueTypeMarker for ScanResultWatcherWatchResponse {
3600        type Borrowed<'a> = &'a Self;
3601        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3602            value
3603        }
3604    }
3605
3606    unsafe impl fidl::encoding::TypeMarker for ScanResultWatcherWatchResponse {
3607        type Owned = Self;
3608
3609        #[inline(always)]
3610        fn inline_align(_context: fidl::encoding::Context) -> usize {
3611            8
3612        }
3613
3614        #[inline(always)]
3615        fn inline_size(_context: fidl::encoding::Context) -> usize {
3616            16
3617        }
3618    }
3619
3620    unsafe impl<D: fidl::encoding::ResourceDialect>
3621        fidl::encoding::Encode<ScanResultWatcherWatchResponse, D>
3622        for &ScanResultWatcherWatchResponse
3623    {
3624        #[inline]
3625        unsafe fn encode(
3626            self,
3627            encoder: &mut fidl::encoding::Encoder<'_, D>,
3628            offset: usize,
3629            _depth: fidl::encoding::Depth,
3630        ) -> fidl::Result<()> {
3631            encoder.debug_check_bounds::<ScanResultWatcherWatchResponse>(offset);
3632            // Delegate to tuple encoding.
3633            fidl::encoding::Encode::<ScanResultWatcherWatchResponse, D>::encode(
3634                (
3635                    <fidl::encoding::UnboundedVector<Peer> as fidl::encoding::ValueTypeMarker>::borrow(&self.updated),
3636                ),
3637                encoder, offset, _depth
3638            )
3639        }
3640    }
3641    unsafe impl<
3642            D: fidl::encoding::ResourceDialect,
3643            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<Peer>, D>,
3644        > fidl::encoding::Encode<ScanResultWatcherWatchResponse, D> for (T0,)
3645    {
3646        #[inline]
3647        unsafe fn encode(
3648            self,
3649            encoder: &mut fidl::encoding::Encoder<'_, D>,
3650            offset: usize,
3651            depth: fidl::encoding::Depth,
3652        ) -> fidl::Result<()> {
3653            encoder.debug_check_bounds::<ScanResultWatcherWatchResponse>(offset);
3654            // Zero out padding regions. There's no need to apply masks
3655            // because the unmasked parts will be overwritten by fields.
3656            // Write the fields.
3657            self.0.encode(encoder, offset + 0, depth)?;
3658            Ok(())
3659        }
3660    }
3661
3662    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3663        for ScanResultWatcherWatchResponse
3664    {
3665        #[inline(always)]
3666        fn new_empty() -> Self {
3667            Self { updated: fidl::new_empty!(fidl::encoding::UnboundedVector<Peer>, D) }
3668        }
3669
3670        #[inline]
3671        unsafe fn decode(
3672            &mut self,
3673            decoder: &mut fidl::encoding::Decoder<'_, D>,
3674            offset: usize,
3675            _depth: fidl::encoding::Depth,
3676        ) -> fidl::Result<()> {
3677            decoder.debug_check_bounds::<Self>(offset);
3678            // Verify that padding bytes are zero.
3679            fidl::decode!(
3680                fidl::encoding::UnboundedVector<Peer>,
3681                D,
3682                &mut self.updated,
3683                decoder,
3684                offset + 0,
3685                _depth
3686            )?;
3687            Ok(())
3688        }
3689    }
3690
3691    impl fidl::encoding::ValueTypeMarker for ServiceData {
3692        type Borrowed<'a> = &'a Self;
3693        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3694            value
3695        }
3696    }
3697
3698    unsafe impl fidl::encoding::TypeMarker for ServiceData {
3699        type Owned = Self;
3700
3701        #[inline(always)]
3702        fn inline_align(_context: fidl::encoding::Context) -> usize {
3703            8
3704        }
3705
3706        #[inline(always)]
3707        fn inline_size(_context: fidl::encoding::Context) -> usize {
3708            32
3709        }
3710    }
3711
3712    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ServiceData, D>
3713        for &ServiceData
3714    {
3715        #[inline]
3716        unsafe fn encode(
3717            self,
3718            encoder: &mut fidl::encoding::Encoder<'_, D>,
3719            offset: usize,
3720            _depth: fidl::encoding::Depth,
3721        ) -> fidl::Result<()> {
3722            encoder.debug_check_bounds::<ServiceData>(offset);
3723            // Delegate to tuple encoding.
3724            fidl::encoding::Encode::<ServiceData, D>::encode(
3725                (
3726                    <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow(&self.uuid),
3727                    <fidl::encoding::Vector<u8, 252> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
3728                ),
3729                encoder, offset, _depth
3730            )
3731        }
3732    }
3733    unsafe impl<
3734            D: fidl::encoding::ResourceDialect,
3735            T0: fidl::encoding::Encode<fidl_fuchsia_bluetooth__common::Uuid, D>,
3736            T1: fidl::encoding::Encode<fidl::encoding::Vector<u8, 252>, D>,
3737        > fidl::encoding::Encode<ServiceData, D> for (T0, T1)
3738    {
3739        #[inline]
3740        unsafe fn encode(
3741            self,
3742            encoder: &mut fidl::encoding::Encoder<'_, D>,
3743            offset: usize,
3744            depth: fidl::encoding::Depth,
3745        ) -> fidl::Result<()> {
3746            encoder.debug_check_bounds::<ServiceData>(offset);
3747            // Zero out padding regions. There's no need to apply masks
3748            // because the unmasked parts will be overwritten by fields.
3749            // Write the fields.
3750            self.0.encode(encoder, offset + 0, depth)?;
3751            self.1.encode(encoder, offset + 16, depth)?;
3752            Ok(())
3753        }
3754    }
3755
3756    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ServiceData {
3757        #[inline(always)]
3758        fn new_empty() -> Self {
3759            Self {
3760                uuid: fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D),
3761                data: fidl::new_empty!(fidl::encoding::Vector<u8, 252>, D),
3762            }
3763        }
3764
3765        #[inline]
3766        unsafe fn decode(
3767            &mut self,
3768            decoder: &mut fidl::encoding::Decoder<'_, D>,
3769            offset: usize,
3770            _depth: fidl::encoding::Depth,
3771        ) -> fidl::Result<()> {
3772            decoder.debug_check_bounds::<Self>(offset);
3773            // Verify that padding bytes are zero.
3774            fidl::decode!(
3775                fidl_fuchsia_bluetooth__common::Uuid,
3776                D,
3777                &mut self.uuid,
3778                decoder,
3779                offset + 0,
3780                _depth
3781            )?;
3782            fidl::decode!(fidl::encoding::Vector<u8, 252>, D, &mut self.data, decoder, offset + 16, _depth)?;
3783            Ok(())
3784        }
3785    }
3786
3787    impl fidl::encoding::ValueTypeMarker for ServiceDataEntry {
3788        type Borrowed<'a> = &'a Self;
3789        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3790            value
3791        }
3792    }
3793
3794    unsafe impl fidl::encoding::TypeMarker for ServiceDataEntry {
3795        type Owned = Self;
3796
3797        #[inline(always)]
3798        fn inline_align(_context: fidl::encoding::Context) -> usize {
3799            8
3800        }
3801
3802        #[inline(always)]
3803        fn inline_size(_context: fidl::encoding::Context) -> usize {
3804            32
3805        }
3806    }
3807
3808    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ServiceDataEntry, D>
3809        for &ServiceDataEntry
3810    {
3811        #[inline]
3812        unsafe fn encode(
3813            self,
3814            encoder: &mut fidl::encoding::Encoder<'_, D>,
3815            offset: usize,
3816            _depth: fidl::encoding::Depth,
3817        ) -> fidl::Result<()> {
3818            encoder.debug_check_bounds::<ServiceDataEntry>(offset);
3819            // Delegate to tuple encoding.
3820            fidl::encoding::Encode::<ServiceDataEntry, D>::encode(
3821                (
3822                    <fidl::encoding::BoundedString<36> as fidl::encoding::ValueTypeMarker>::borrow(&self.uuid),
3823                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.data),
3824                ),
3825                encoder, offset, _depth
3826            )
3827        }
3828    }
3829    unsafe impl<
3830            D: fidl::encoding::ResourceDialect,
3831            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<36>, D>,
3832            T1: fidl::encoding::Encode<fidl::encoding::UnboundedVector<u8>, D>,
3833        > fidl::encoding::Encode<ServiceDataEntry, D> for (T0, T1)
3834    {
3835        #[inline]
3836        unsafe fn encode(
3837            self,
3838            encoder: &mut fidl::encoding::Encoder<'_, D>,
3839            offset: usize,
3840            depth: fidl::encoding::Depth,
3841        ) -> fidl::Result<()> {
3842            encoder.debug_check_bounds::<ServiceDataEntry>(offset);
3843            // Zero out padding regions. There's no need to apply masks
3844            // because the unmasked parts will be overwritten by fields.
3845            // Write the fields.
3846            self.0.encode(encoder, offset + 0, depth)?;
3847            self.1.encode(encoder, offset + 16, depth)?;
3848            Ok(())
3849        }
3850    }
3851
3852    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ServiceDataEntry {
3853        #[inline(always)]
3854        fn new_empty() -> Self {
3855            Self {
3856                uuid: fidl::new_empty!(fidl::encoding::BoundedString<36>, D),
3857                data: fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D),
3858            }
3859        }
3860
3861        #[inline]
3862        unsafe fn decode(
3863            &mut self,
3864            decoder: &mut fidl::encoding::Decoder<'_, D>,
3865            offset: usize,
3866            _depth: fidl::encoding::Depth,
3867        ) -> fidl::Result<()> {
3868            decoder.debug_check_bounds::<Self>(offset);
3869            // Verify that padding bytes are zero.
3870            fidl::decode!(
3871                fidl::encoding::BoundedString<36>,
3872                D,
3873                &mut self.uuid,
3874                decoder,
3875                offset + 0,
3876                _depth
3877            )?;
3878            fidl::decode!(
3879                fidl::encoding::UnboundedVector<u8>,
3880                D,
3881                &mut self.data,
3882                decoder,
3883                offset + 16,
3884                _depth
3885            )?;
3886            Ok(())
3887        }
3888    }
3889
3890    impl AcceptedChannelParameters {
3891        #[inline(always)]
3892        fn max_ordinal_present(&self) -> u64 {
3893            if let Some(_) = self.max_packet_size {
3894                return 2;
3895            }
3896            if let Some(_) = self.accepted_channel_modes {
3897                return 1;
3898            }
3899            0
3900        }
3901    }
3902
3903    impl fidl::encoding::ValueTypeMarker for AcceptedChannelParameters {
3904        type Borrowed<'a> = &'a Self;
3905        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3906            value
3907        }
3908    }
3909
3910    unsafe impl fidl::encoding::TypeMarker for AcceptedChannelParameters {
3911        type Owned = Self;
3912
3913        #[inline(always)]
3914        fn inline_align(_context: fidl::encoding::Context) -> usize {
3915            8
3916        }
3917
3918        #[inline(always)]
3919        fn inline_size(_context: fidl::encoding::Context) -> usize {
3920            16
3921        }
3922    }
3923
3924    unsafe impl<D: fidl::encoding::ResourceDialect>
3925        fidl::encoding::Encode<AcceptedChannelParameters, D> for &AcceptedChannelParameters
3926    {
3927        unsafe fn encode(
3928            self,
3929            encoder: &mut fidl::encoding::Encoder<'_, D>,
3930            offset: usize,
3931            mut depth: fidl::encoding::Depth,
3932        ) -> fidl::Result<()> {
3933            encoder.debug_check_bounds::<AcceptedChannelParameters>(offset);
3934            // Vector header
3935            let max_ordinal: u64 = self.max_ordinal_present();
3936            encoder.write_num(max_ordinal, offset);
3937            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3938            // Calling encoder.out_of_line_offset(0) is not allowed.
3939            if max_ordinal == 0 {
3940                return Ok(());
3941            }
3942            depth.increment()?;
3943            let envelope_size = 8;
3944            let bytes_len = max_ordinal as usize * envelope_size;
3945            #[allow(unused_variables)]
3946            let offset = encoder.out_of_line_offset(bytes_len);
3947            let mut _prev_end_offset: usize = 0;
3948            if 1 > max_ordinal {
3949                return Ok(());
3950            }
3951
3952            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3953            // are envelope_size bytes.
3954            let cur_offset: usize = (1 - 1) * envelope_size;
3955
3956            // Zero reserved fields.
3957            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3958
3959            // Safety:
3960            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3961            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3962            //   envelope_size bytes, there is always sufficient room.
3963            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::ChannelMode>, D>(
3964            self.accepted_channel_modes.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::ChannelMode> as fidl::encoding::ValueTypeMarker>::borrow),
3965            encoder, offset + cur_offset, depth
3966        )?;
3967
3968            _prev_end_offset = cur_offset + envelope_size;
3969            if 2 > max_ordinal {
3970                return Ok(());
3971            }
3972
3973            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3974            // are envelope_size bytes.
3975            let cur_offset: usize = (2 - 1) * envelope_size;
3976
3977            // Zero reserved fields.
3978            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3979
3980            // Safety:
3981            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3982            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3983            //   envelope_size bytes, there is always sufficient room.
3984            fidl::encoding::encode_in_envelope_optional::<u16, D>(
3985                self.max_packet_size.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3986                encoder,
3987                offset + cur_offset,
3988                depth,
3989            )?;
3990
3991            _prev_end_offset = cur_offset + envelope_size;
3992
3993            Ok(())
3994        }
3995    }
3996
3997    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3998        for AcceptedChannelParameters
3999    {
4000        #[inline(always)]
4001        fn new_empty() -> Self {
4002            Self::default()
4003        }
4004
4005        unsafe fn decode(
4006            &mut self,
4007            decoder: &mut fidl::encoding::Decoder<'_, D>,
4008            offset: usize,
4009            mut depth: fidl::encoding::Depth,
4010        ) -> fidl::Result<()> {
4011            decoder.debug_check_bounds::<Self>(offset);
4012            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4013                None => return Err(fidl::Error::NotNullable),
4014                Some(len) => len,
4015            };
4016            // Calling decoder.out_of_line_offset(0) is not allowed.
4017            if len == 0 {
4018                return Ok(());
4019            };
4020            depth.increment()?;
4021            let envelope_size = 8;
4022            let bytes_len = len * envelope_size;
4023            let offset = decoder.out_of_line_offset(bytes_len)?;
4024            // Decode the envelope for each type.
4025            let mut _next_ordinal_to_read = 0;
4026            let mut next_offset = offset;
4027            let end_offset = offset + bytes_len;
4028            _next_ordinal_to_read += 1;
4029            if next_offset >= end_offset {
4030                return Ok(());
4031            }
4032
4033            // Decode unknown envelopes for gaps in ordinals.
4034            while _next_ordinal_to_read < 1 {
4035                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4036                _next_ordinal_to_read += 1;
4037                next_offset += envelope_size;
4038            }
4039
4040            let next_out_of_line = decoder.next_out_of_line();
4041            let handles_before = decoder.remaining_handles();
4042            if let Some((inlined, num_bytes, num_handles)) =
4043                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4044            {
4045                let member_inline_size = <fidl::encoding::UnboundedVector<
4046                    fidl_fuchsia_bluetooth__common::ChannelMode,
4047                > as fidl::encoding::TypeMarker>::inline_size(
4048                    decoder.context
4049                );
4050                if inlined != (member_inline_size <= 4) {
4051                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4052                }
4053                let inner_offset;
4054                let mut inner_depth = depth.clone();
4055                if inlined {
4056                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4057                    inner_offset = next_offset;
4058                } else {
4059                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4060                    inner_depth.increment()?;
4061                }
4062                let val_ref = self.accepted_channel_modes.get_or_insert_with(|| {
4063                    fidl::new_empty!(
4064                        fidl::encoding::UnboundedVector<
4065                            fidl_fuchsia_bluetooth__common::ChannelMode,
4066                        >,
4067                        D
4068                    )
4069                });
4070                fidl::decode!(
4071                    fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::ChannelMode>,
4072                    D,
4073                    val_ref,
4074                    decoder,
4075                    inner_offset,
4076                    inner_depth
4077                )?;
4078                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4079                {
4080                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4081                }
4082                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4083                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4084                }
4085            }
4086
4087            next_offset += envelope_size;
4088            _next_ordinal_to_read += 1;
4089            if next_offset >= end_offset {
4090                return Ok(());
4091            }
4092
4093            // Decode unknown envelopes for gaps in ordinals.
4094            while _next_ordinal_to_read < 2 {
4095                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4096                _next_ordinal_to_read += 1;
4097                next_offset += envelope_size;
4098            }
4099
4100            let next_out_of_line = decoder.next_out_of_line();
4101            let handles_before = decoder.remaining_handles();
4102            if let Some((inlined, num_bytes, num_handles)) =
4103                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4104            {
4105                let member_inline_size =
4106                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4107                if inlined != (member_inline_size <= 4) {
4108                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4109                }
4110                let inner_offset;
4111                let mut inner_depth = depth.clone();
4112                if inlined {
4113                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4114                    inner_offset = next_offset;
4115                } else {
4116                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4117                    inner_depth.increment()?;
4118                }
4119                let val_ref = self.max_packet_size.get_or_insert_with(|| fidl::new_empty!(u16, D));
4120                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4121                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4122                {
4123                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4124                }
4125                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4126                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4127                }
4128            }
4129
4130            next_offset += envelope_size;
4131
4132            // Decode the remaining unknown envelopes.
4133            while next_offset < end_offset {
4134                _next_ordinal_to_read += 1;
4135                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4136                next_offset += envelope_size;
4137            }
4138
4139            Ok(())
4140        }
4141    }
4142
4143    impl AdvertisingData {
4144        #[inline(always)]
4145        fn max_ordinal_present(&self) -> u64 {
4146            if let Some(_) = self.broadcast_name {
4147                return 10;
4148            }
4149            if let Some(_) = self.resolvable_set_identifier {
4150                return 9;
4151            }
4152            if let Some(_) = self.include_tx_power_level {
4153                return 8;
4154            }
4155            if let Some(_) = self.uris {
4156                return 7;
4157            }
4158            if let Some(_) = self.manufacturer_data {
4159                return 6;
4160            }
4161            if let Some(_) = self.service_data {
4162                return 5;
4163            }
4164            if let Some(_) = self.service_uuids {
4165                return 4;
4166            }
4167            if let Some(_) = self.tx_power_level {
4168                return 3;
4169            }
4170            if let Some(_) = self.appearance {
4171                return 2;
4172            }
4173            if let Some(_) = self.name {
4174                return 1;
4175            }
4176            0
4177        }
4178    }
4179
4180    impl fidl::encoding::ValueTypeMarker for AdvertisingData {
4181        type Borrowed<'a> = &'a Self;
4182        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4183            value
4184        }
4185    }
4186
4187    unsafe impl fidl::encoding::TypeMarker for AdvertisingData {
4188        type Owned = Self;
4189
4190        #[inline(always)]
4191        fn inline_align(_context: fidl::encoding::Context) -> usize {
4192            8
4193        }
4194
4195        #[inline(always)]
4196        fn inline_size(_context: fidl::encoding::Context) -> usize {
4197            16
4198        }
4199    }
4200
4201    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AdvertisingData, D>
4202        for &AdvertisingData
4203    {
4204        unsafe fn encode(
4205            self,
4206            encoder: &mut fidl::encoding::Encoder<'_, D>,
4207            offset: usize,
4208            mut depth: fidl::encoding::Depth,
4209        ) -> fidl::Result<()> {
4210            encoder.debug_check_bounds::<AdvertisingData>(offset);
4211            // Vector header
4212            let max_ordinal: u64 = self.max_ordinal_present();
4213            encoder.write_num(max_ordinal, offset);
4214            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4215            // Calling encoder.out_of_line_offset(0) is not allowed.
4216            if max_ordinal == 0 {
4217                return Ok(());
4218            }
4219            depth.increment()?;
4220            let envelope_size = 8;
4221            let bytes_len = max_ordinal as usize * envelope_size;
4222            #[allow(unused_variables)]
4223            let offset = encoder.out_of_line_offset(bytes_len);
4224            let mut _prev_end_offset: usize = 0;
4225            if 1 > max_ordinal {
4226                return Ok(());
4227            }
4228
4229            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4230            // are envelope_size bytes.
4231            let cur_offset: usize = (1 - 1) * envelope_size;
4232
4233            // Zero reserved fields.
4234            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4235
4236            // Safety:
4237            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4238            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4239            //   envelope_size bytes, there is always sufficient room.
4240            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<248>, D>(
4241                self.name.as_ref().map(
4242                    <fidl::encoding::BoundedString<248> as fidl::encoding::ValueTypeMarker>::borrow,
4243                ),
4244                encoder,
4245                offset + cur_offset,
4246                depth,
4247            )?;
4248
4249            _prev_end_offset = cur_offset + envelope_size;
4250            if 2 > max_ordinal {
4251                return Ok(());
4252            }
4253
4254            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4255            // are envelope_size bytes.
4256            let cur_offset: usize = (2 - 1) * envelope_size;
4257
4258            // Zero reserved fields.
4259            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4260
4261            // Safety:
4262            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4263            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4264            //   envelope_size bytes, there is always sufficient room.
4265            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Appearance, D>(
4266            self.appearance.as_ref().map(<fidl_fuchsia_bluetooth__common::Appearance as fidl::encoding::ValueTypeMarker>::borrow),
4267            encoder, offset + cur_offset, depth
4268        )?;
4269
4270            _prev_end_offset = cur_offset + envelope_size;
4271            if 3 > max_ordinal {
4272                return Ok(());
4273            }
4274
4275            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4276            // are envelope_size bytes.
4277            let cur_offset: usize = (3 - 1) * envelope_size;
4278
4279            // Zero reserved fields.
4280            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4281
4282            // Safety:
4283            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4284            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4285            //   envelope_size bytes, there is always sufficient room.
4286            fidl::encoding::encode_in_envelope_optional::<i8, D>(
4287                self.tx_power_level.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
4288                encoder,
4289                offset + cur_offset,
4290                depth,
4291            )?;
4292
4293            _prev_end_offset = cur_offset + envelope_size;
4294            if 4 > max_ordinal {
4295                return Ok(());
4296            }
4297
4298            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4299            // are envelope_size bytes.
4300            let cur_offset: usize = (4 - 1) * envelope_size;
4301
4302            // Zero reserved fields.
4303            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4304
4305            // Safety:
4306            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4307            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4308            //   envelope_size bytes, there is always sufficient room.
4309            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>, D>(
4310            self.service_uuids.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid> as fidl::encoding::ValueTypeMarker>::borrow),
4311            encoder, offset + cur_offset, depth
4312        )?;
4313
4314            _prev_end_offset = cur_offset + envelope_size;
4315            if 5 > max_ordinal {
4316                return Ok(());
4317            }
4318
4319            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4320            // are envelope_size bytes.
4321            let cur_offset: usize = (5 - 1) * envelope_size;
4322
4323            // Zero reserved fields.
4324            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4325
4326            // Safety:
4327            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4328            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4329            //   envelope_size bytes, there is always sufficient room.
4330            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ServiceData>, D>(
4331            self.service_data.as_ref().map(<fidl::encoding::UnboundedVector<ServiceData> as fidl::encoding::ValueTypeMarker>::borrow),
4332            encoder, offset + cur_offset, depth
4333        )?;
4334
4335            _prev_end_offset = cur_offset + envelope_size;
4336            if 6 > max_ordinal {
4337                return Ok(());
4338            }
4339
4340            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4341            // are envelope_size bytes.
4342            let cur_offset: usize = (6 - 1) * envelope_size;
4343
4344            // Zero reserved fields.
4345            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4346
4347            // Safety:
4348            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4349            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4350            //   envelope_size bytes, there is always sufficient room.
4351            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ManufacturerData>, D>(
4352            self.manufacturer_data.as_ref().map(<fidl::encoding::UnboundedVector<ManufacturerData> as fidl::encoding::ValueTypeMarker>::borrow),
4353            encoder, offset + cur_offset, depth
4354        )?;
4355
4356            _prev_end_offset = cur_offset + envelope_size;
4357            if 7 > max_ordinal {
4358                return Ok(());
4359            }
4360
4361            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4362            // are envelope_size bytes.
4363            let cur_offset: usize = (7 - 1) * envelope_size;
4364
4365            // Zero reserved fields.
4366            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4367
4368            // Safety:
4369            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4370            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4371            //   envelope_size bytes, there is always sufficient room.
4372            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>, D>(
4373            self.uris.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>> as fidl::encoding::ValueTypeMarker>::borrow),
4374            encoder, offset + cur_offset, depth
4375        )?;
4376
4377            _prev_end_offset = cur_offset + envelope_size;
4378            if 8 > max_ordinal {
4379                return Ok(());
4380            }
4381
4382            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4383            // are envelope_size bytes.
4384            let cur_offset: usize = (8 - 1) * envelope_size;
4385
4386            // Zero reserved fields.
4387            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4388
4389            // Safety:
4390            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4391            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4392            //   envelope_size bytes, there is always sufficient room.
4393            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4394                self.include_tx_power_level
4395                    .as_ref()
4396                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4397                encoder,
4398                offset + cur_offset,
4399                depth,
4400            )?;
4401
4402            _prev_end_offset = cur_offset + envelope_size;
4403            if 9 > max_ordinal {
4404                return Ok(());
4405            }
4406
4407            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4408            // are envelope_size bytes.
4409            let cur_offset: usize = (9 - 1) * envelope_size;
4410
4411            // Zero reserved fields.
4412            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4413
4414            // Safety:
4415            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4416            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4417            //   envelope_size bytes, there is always sufficient room.
4418            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 6>, D>(
4419                self.resolvable_set_identifier
4420                    .as_ref()
4421                    .map(<fidl::encoding::Array<u8, 6> as fidl::encoding::ValueTypeMarker>::borrow),
4422                encoder,
4423                offset + cur_offset,
4424                depth,
4425            )?;
4426
4427            _prev_end_offset = cur_offset + envelope_size;
4428            if 10 > 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 = (10 - 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::BoundedString<128>, D>(
4444                self.broadcast_name.as_ref().map(
4445                    <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow,
4446                ),
4447                encoder,
4448                offset + cur_offset,
4449                depth,
4450            )?;
4451
4452            _prev_end_offset = cur_offset + envelope_size;
4453
4454            Ok(())
4455        }
4456    }
4457
4458    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvertisingData {
4459        #[inline(always)]
4460        fn new_empty() -> Self {
4461            Self::default()
4462        }
4463
4464        unsafe fn decode(
4465            &mut self,
4466            decoder: &mut fidl::encoding::Decoder<'_, D>,
4467            offset: usize,
4468            mut depth: fidl::encoding::Depth,
4469        ) -> fidl::Result<()> {
4470            decoder.debug_check_bounds::<Self>(offset);
4471            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4472                None => return Err(fidl::Error::NotNullable),
4473                Some(len) => len,
4474            };
4475            // Calling decoder.out_of_line_offset(0) is not allowed.
4476            if len == 0 {
4477                return Ok(());
4478            };
4479            depth.increment()?;
4480            let envelope_size = 8;
4481            let bytes_len = len * envelope_size;
4482            let offset = decoder.out_of_line_offset(bytes_len)?;
4483            // Decode the envelope for each type.
4484            let mut _next_ordinal_to_read = 0;
4485            let mut next_offset = offset;
4486            let end_offset = offset + bytes_len;
4487            _next_ordinal_to_read += 1;
4488            if next_offset >= end_offset {
4489                return Ok(());
4490            }
4491
4492            // Decode unknown envelopes for gaps in ordinals.
4493            while _next_ordinal_to_read < 1 {
4494                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4495                _next_ordinal_to_read += 1;
4496                next_offset += envelope_size;
4497            }
4498
4499            let next_out_of_line = decoder.next_out_of_line();
4500            let handles_before = decoder.remaining_handles();
4501            if let Some((inlined, num_bytes, num_handles)) =
4502                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4503            {
4504                let member_inline_size =
4505                    <fidl::encoding::BoundedString<248> as fidl::encoding::TypeMarker>::inline_size(
4506                        decoder.context,
4507                    );
4508                if inlined != (member_inline_size <= 4) {
4509                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4510                }
4511                let inner_offset;
4512                let mut inner_depth = depth.clone();
4513                if inlined {
4514                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4515                    inner_offset = next_offset;
4516                } else {
4517                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4518                    inner_depth.increment()?;
4519                }
4520                let val_ref = self
4521                    .name
4522                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<248>, D));
4523                fidl::decode!(
4524                    fidl::encoding::BoundedString<248>,
4525                    D,
4526                    val_ref,
4527                    decoder,
4528                    inner_offset,
4529                    inner_depth
4530                )?;
4531                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4532                {
4533                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4534                }
4535                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4536                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4537                }
4538            }
4539
4540            next_offset += envelope_size;
4541            _next_ordinal_to_read += 1;
4542            if next_offset >= end_offset {
4543                return Ok(());
4544            }
4545
4546            // Decode unknown envelopes for gaps in ordinals.
4547            while _next_ordinal_to_read < 2 {
4548                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4549                _next_ordinal_to_read += 1;
4550                next_offset += envelope_size;
4551            }
4552
4553            let next_out_of_line = decoder.next_out_of_line();
4554            let handles_before = decoder.remaining_handles();
4555            if let Some((inlined, num_bytes, num_handles)) =
4556                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4557            {
4558                let member_inline_size = <fidl_fuchsia_bluetooth__common::Appearance as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4559                if inlined != (member_inline_size <= 4) {
4560                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4561                }
4562                let inner_offset;
4563                let mut inner_depth = depth.clone();
4564                if inlined {
4565                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4566                    inner_offset = next_offset;
4567                } else {
4568                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4569                    inner_depth.increment()?;
4570                }
4571                let val_ref = self.appearance.get_or_insert_with(|| {
4572                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::Appearance, D)
4573                });
4574                fidl::decode!(
4575                    fidl_fuchsia_bluetooth__common::Appearance,
4576                    D,
4577                    val_ref,
4578                    decoder,
4579                    inner_offset,
4580                    inner_depth
4581                )?;
4582                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4583                {
4584                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4585                }
4586                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4587                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4588                }
4589            }
4590
4591            next_offset += envelope_size;
4592            _next_ordinal_to_read += 1;
4593            if next_offset >= end_offset {
4594                return Ok(());
4595            }
4596
4597            // Decode unknown envelopes for gaps in ordinals.
4598            while _next_ordinal_to_read < 3 {
4599                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4600                _next_ordinal_to_read += 1;
4601                next_offset += envelope_size;
4602            }
4603
4604            let next_out_of_line = decoder.next_out_of_line();
4605            let handles_before = decoder.remaining_handles();
4606            if let Some((inlined, num_bytes, num_handles)) =
4607                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4608            {
4609                let member_inline_size =
4610                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4611                if inlined != (member_inline_size <= 4) {
4612                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4613                }
4614                let inner_offset;
4615                let mut inner_depth = depth.clone();
4616                if inlined {
4617                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4618                    inner_offset = next_offset;
4619                } else {
4620                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4621                    inner_depth.increment()?;
4622                }
4623                let val_ref = self.tx_power_level.get_or_insert_with(|| fidl::new_empty!(i8, D));
4624                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
4625                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4626                {
4627                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4628                }
4629                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4630                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4631                }
4632            }
4633
4634            next_offset += envelope_size;
4635            _next_ordinal_to_read += 1;
4636            if next_offset >= end_offset {
4637                return Ok(());
4638            }
4639
4640            // Decode unknown envelopes for gaps in ordinals.
4641            while _next_ordinal_to_read < 4 {
4642                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4643                _next_ordinal_to_read += 1;
4644                next_offset += envelope_size;
4645            }
4646
4647            let next_out_of_line = decoder.next_out_of_line();
4648            let handles_before = decoder.remaining_handles();
4649            if let Some((inlined, num_bytes, num_handles)) =
4650                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4651            {
4652                let member_inline_size = <fidl::encoding::UnboundedVector<
4653                    fidl_fuchsia_bluetooth__common::Uuid,
4654                > as fidl::encoding::TypeMarker>::inline_size(
4655                    decoder.context
4656                );
4657                if inlined != (member_inline_size <= 4) {
4658                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4659                }
4660                let inner_offset;
4661                let mut inner_depth = depth.clone();
4662                if inlined {
4663                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4664                    inner_offset = next_offset;
4665                } else {
4666                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4667                    inner_depth.increment()?;
4668                }
4669                let val_ref = self.service_uuids.get_or_insert_with(|| {
4670                    fidl::new_empty!(
4671                        fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>,
4672                        D
4673                    )
4674                });
4675                fidl::decode!(
4676                    fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>,
4677                    D,
4678                    val_ref,
4679                    decoder,
4680                    inner_offset,
4681                    inner_depth
4682                )?;
4683                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4684                {
4685                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4686                }
4687                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4688                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4689                }
4690            }
4691
4692            next_offset += envelope_size;
4693            _next_ordinal_to_read += 1;
4694            if next_offset >= end_offset {
4695                return Ok(());
4696            }
4697
4698            // Decode unknown envelopes for gaps in ordinals.
4699            while _next_ordinal_to_read < 5 {
4700                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4701                _next_ordinal_to_read += 1;
4702                next_offset += envelope_size;
4703            }
4704
4705            let next_out_of_line = decoder.next_out_of_line();
4706            let handles_before = decoder.remaining_handles();
4707            if let Some((inlined, num_bytes, num_handles)) =
4708                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4709            {
4710                let member_inline_size = <fidl::encoding::UnboundedVector<ServiceData> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4711                if inlined != (member_inline_size <= 4) {
4712                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4713                }
4714                let inner_offset;
4715                let mut inner_depth = depth.clone();
4716                if inlined {
4717                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4718                    inner_offset = next_offset;
4719                } else {
4720                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4721                    inner_depth.increment()?;
4722                }
4723                let val_ref = self.service_data.get_or_insert_with(|| {
4724                    fidl::new_empty!(fidl::encoding::UnboundedVector<ServiceData>, D)
4725                });
4726                fidl::decode!(
4727                    fidl::encoding::UnboundedVector<ServiceData>,
4728                    D,
4729                    val_ref,
4730                    decoder,
4731                    inner_offset,
4732                    inner_depth
4733                )?;
4734                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4735                {
4736                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4737                }
4738                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4739                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4740                }
4741            }
4742
4743            next_offset += envelope_size;
4744            _next_ordinal_to_read += 1;
4745            if next_offset >= end_offset {
4746                return Ok(());
4747            }
4748
4749            // Decode unknown envelopes for gaps in ordinals.
4750            while _next_ordinal_to_read < 6 {
4751                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4752                _next_ordinal_to_read += 1;
4753                next_offset += envelope_size;
4754            }
4755
4756            let next_out_of_line = decoder.next_out_of_line();
4757            let handles_before = decoder.remaining_handles();
4758            if let Some((inlined, num_bytes, num_handles)) =
4759                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4760            {
4761                let member_inline_size = <fidl::encoding::UnboundedVector<ManufacturerData> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4762                if inlined != (member_inline_size <= 4) {
4763                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4764                }
4765                let inner_offset;
4766                let mut inner_depth = depth.clone();
4767                if inlined {
4768                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4769                    inner_offset = next_offset;
4770                } else {
4771                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4772                    inner_depth.increment()?;
4773                }
4774                let val_ref = self.manufacturer_data.get_or_insert_with(|| {
4775                    fidl::new_empty!(fidl::encoding::UnboundedVector<ManufacturerData>, D)
4776                });
4777                fidl::decode!(
4778                    fidl::encoding::UnboundedVector<ManufacturerData>,
4779                    D,
4780                    val_ref,
4781                    decoder,
4782                    inner_offset,
4783                    inner_depth
4784                )?;
4785                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4786                {
4787                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4788                }
4789                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4790                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4791                }
4792            }
4793
4794            next_offset += envelope_size;
4795            _next_ordinal_to_read += 1;
4796            if next_offset >= end_offset {
4797                return Ok(());
4798            }
4799
4800            // Decode unknown envelopes for gaps in ordinals.
4801            while _next_ordinal_to_read < 7 {
4802                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4803                _next_ordinal_to_read += 1;
4804                next_offset += envelope_size;
4805            }
4806
4807            let next_out_of_line = decoder.next_out_of_line();
4808            let handles_before = decoder.remaining_handles();
4809            if let Some((inlined, num_bytes, num_handles)) =
4810                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4811            {
4812                let member_inline_size = <fidl::encoding::UnboundedVector<
4813                    fidl::encoding::BoundedString<278>,
4814                > as fidl::encoding::TypeMarker>::inline_size(
4815                    decoder.context
4816                );
4817                if inlined != (member_inline_size <= 4) {
4818                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4819                }
4820                let inner_offset;
4821                let mut inner_depth = depth.clone();
4822                if inlined {
4823                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4824                    inner_offset = next_offset;
4825                } else {
4826                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4827                    inner_depth.increment()?;
4828                }
4829                let val_ref = self.uris.get_or_insert_with(|| {
4830                    fidl::new_empty!(
4831                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>,
4832                        D
4833                    )
4834                });
4835                fidl::decode!(
4836                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>,
4837                    D,
4838                    val_ref,
4839                    decoder,
4840                    inner_offset,
4841                    inner_depth
4842                )?;
4843                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4844                {
4845                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4846                }
4847                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4848                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4849                }
4850            }
4851
4852            next_offset += envelope_size;
4853            _next_ordinal_to_read += 1;
4854            if next_offset >= end_offset {
4855                return Ok(());
4856            }
4857
4858            // Decode unknown envelopes for gaps in ordinals.
4859            while _next_ordinal_to_read < 8 {
4860                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4861                _next_ordinal_to_read += 1;
4862                next_offset += envelope_size;
4863            }
4864
4865            let next_out_of_line = decoder.next_out_of_line();
4866            let handles_before = decoder.remaining_handles();
4867            if let Some((inlined, num_bytes, num_handles)) =
4868                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4869            {
4870                let member_inline_size =
4871                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4872                if inlined != (member_inline_size <= 4) {
4873                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4874                }
4875                let inner_offset;
4876                let mut inner_depth = depth.clone();
4877                if inlined {
4878                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4879                    inner_offset = next_offset;
4880                } else {
4881                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4882                    inner_depth.increment()?;
4883                }
4884                let val_ref =
4885                    self.include_tx_power_level.get_or_insert_with(|| fidl::new_empty!(bool, D));
4886                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4887                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4888                {
4889                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4890                }
4891                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4892                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4893                }
4894            }
4895
4896            next_offset += envelope_size;
4897            _next_ordinal_to_read += 1;
4898            if next_offset >= end_offset {
4899                return Ok(());
4900            }
4901
4902            // Decode unknown envelopes for gaps in ordinals.
4903            while _next_ordinal_to_read < 9 {
4904                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4905                _next_ordinal_to_read += 1;
4906                next_offset += envelope_size;
4907            }
4908
4909            let next_out_of_line = decoder.next_out_of_line();
4910            let handles_before = decoder.remaining_handles();
4911            if let Some((inlined, num_bytes, num_handles)) =
4912                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4913            {
4914                let member_inline_size =
4915                    <fidl::encoding::Array<u8, 6> as fidl::encoding::TypeMarker>::inline_size(
4916                        decoder.context,
4917                    );
4918                if inlined != (member_inline_size <= 4) {
4919                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4920                }
4921                let inner_offset;
4922                let mut inner_depth = depth.clone();
4923                if inlined {
4924                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4925                    inner_offset = next_offset;
4926                } else {
4927                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4928                    inner_depth.increment()?;
4929                }
4930                let val_ref = self
4931                    .resolvable_set_identifier
4932                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 6>, D));
4933                fidl::decode!(fidl::encoding::Array<u8, 6>, D, val_ref, decoder, inner_offset, inner_depth)?;
4934                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4935                {
4936                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4937                }
4938                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4939                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4940                }
4941            }
4942
4943            next_offset += envelope_size;
4944            _next_ordinal_to_read += 1;
4945            if next_offset >= end_offset {
4946                return Ok(());
4947            }
4948
4949            // Decode unknown envelopes for gaps in ordinals.
4950            while _next_ordinal_to_read < 10 {
4951                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4952                _next_ordinal_to_read += 1;
4953                next_offset += envelope_size;
4954            }
4955
4956            let next_out_of_line = decoder.next_out_of_line();
4957            let handles_before = decoder.remaining_handles();
4958            if let Some((inlined, num_bytes, num_handles)) =
4959                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4960            {
4961                let member_inline_size =
4962                    <fidl::encoding::BoundedString<128> as fidl::encoding::TypeMarker>::inline_size(
4963                        decoder.context,
4964                    );
4965                if inlined != (member_inline_size <= 4) {
4966                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4967                }
4968                let inner_offset;
4969                let mut inner_depth = depth.clone();
4970                if inlined {
4971                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4972                    inner_offset = next_offset;
4973                } else {
4974                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4975                    inner_depth.increment()?;
4976                }
4977                let val_ref = self
4978                    .broadcast_name
4979                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<128>, D));
4980                fidl::decode!(
4981                    fidl::encoding::BoundedString<128>,
4982                    D,
4983                    val_ref,
4984                    decoder,
4985                    inner_offset,
4986                    inner_depth
4987                )?;
4988                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4989                {
4990                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4991                }
4992                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4993                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4994                }
4995            }
4996
4997            next_offset += envelope_size;
4998
4999            // Decode the remaining unknown envelopes.
5000            while next_offset < end_offset {
5001                _next_ordinal_to_read += 1;
5002                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5003                next_offset += envelope_size;
5004            }
5005
5006            Ok(())
5007        }
5008    }
5009
5010    impl AdvertisingParameters {
5011        #[inline(always)]
5012        fn max_ordinal_present(&self) -> u64 {
5013            if let Some(_) = self.address_type {
5014                return 7;
5015            }
5016            if let Some(_) = self.advertising_procedure {
5017                return 6;
5018            }
5019            if let Some(_) = self.connection_options {
5020                return 5;
5021            }
5022            if let Some(_) = self.connectable {
5023                return 4;
5024            }
5025            if let Some(_) = self.mode_hint {
5026                return 3;
5027            }
5028            if let Some(_) = self.scan_response {
5029                return 2;
5030            }
5031            if let Some(_) = self.data {
5032                return 1;
5033            }
5034            0
5035        }
5036    }
5037
5038    impl fidl::encoding::ValueTypeMarker for AdvertisingParameters {
5039        type Borrowed<'a> = &'a Self;
5040        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5041            value
5042        }
5043    }
5044
5045    unsafe impl fidl::encoding::TypeMarker for AdvertisingParameters {
5046        type Owned = Self;
5047
5048        #[inline(always)]
5049        fn inline_align(_context: fidl::encoding::Context) -> usize {
5050            8
5051        }
5052
5053        #[inline(always)]
5054        fn inline_size(_context: fidl::encoding::Context) -> usize {
5055            16
5056        }
5057    }
5058
5059    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AdvertisingParameters, D>
5060        for &AdvertisingParameters
5061    {
5062        unsafe fn encode(
5063            self,
5064            encoder: &mut fidl::encoding::Encoder<'_, D>,
5065            offset: usize,
5066            mut depth: fidl::encoding::Depth,
5067        ) -> fidl::Result<()> {
5068            encoder.debug_check_bounds::<AdvertisingParameters>(offset);
5069            // Vector header
5070            let max_ordinal: u64 = self.max_ordinal_present();
5071            encoder.write_num(max_ordinal, offset);
5072            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5073            // Calling encoder.out_of_line_offset(0) is not allowed.
5074            if max_ordinal == 0 {
5075                return Ok(());
5076            }
5077            depth.increment()?;
5078            let envelope_size = 8;
5079            let bytes_len = max_ordinal as usize * envelope_size;
5080            #[allow(unused_variables)]
5081            let offset = encoder.out_of_line_offset(bytes_len);
5082            let mut _prev_end_offset: usize = 0;
5083            if 1 > max_ordinal {
5084                return Ok(());
5085            }
5086
5087            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5088            // are envelope_size bytes.
5089            let cur_offset: usize = (1 - 1) * envelope_size;
5090
5091            // Zero reserved fields.
5092            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5093
5094            // Safety:
5095            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5096            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5097            //   envelope_size bytes, there is always sufficient room.
5098            fidl::encoding::encode_in_envelope_optional::<AdvertisingData, D>(
5099                self.data
5100                    .as_ref()
5101                    .map(<AdvertisingData as fidl::encoding::ValueTypeMarker>::borrow),
5102                encoder,
5103                offset + cur_offset,
5104                depth,
5105            )?;
5106
5107            _prev_end_offset = cur_offset + envelope_size;
5108            if 2 > max_ordinal {
5109                return Ok(());
5110            }
5111
5112            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5113            // are envelope_size bytes.
5114            let cur_offset: usize = (2 - 1) * envelope_size;
5115
5116            // Zero reserved fields.
5117            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5118
5119            // Safety:
5120            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5121            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5122            //   envelope_size bytes, there is always sufficient room.
5123            fidl::encoding::encode_in_envelope_optional::<AdvertisingData, D>(
5124                self.scan_response
5125                    .as_ref()
5126                    .map(<AdvertisingData as fidl::encoding::ValueTypeMarker>::borrow),
5127                encoder,
5128                offset + cur_offset,
5129                depth,
5130            )?;
5131
5132            _prev_end_offset = cur_offset + envelope_size;
5133            if 3 > max_ordinal {
5134                return Ok(());
5135            }
5136
5137            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5138            // are envelope_size bytes.
5139            let cur_offset: usize = (3 - 1) * envelope_size;
5140
5141            // Zero reserved fields.
5142            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5143
5144            // Safety:
5145            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5146            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5147            //   envelope_size bytes, there is always sufficient room.
5148            fidl::encoding::encode_in_envelope_optional::<AdvertisingModeHint, D>(
5149                self.mode_hint
5150                    .as_ref()
5151                    .map(<AdvertisingModeHint as fidl::encoding::ValueTypeMarker>::borrow),
5152                encoder,
5153                offset + cur_offset,
5154                depth,
5155            )?;
5156
5157            _prev_end_offset = cur_offset + envelope_size;
5158            if 4 > max_ordinal {
5159                return Ok(());
5160            }
5161
5162            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5163            // are envelope_size bytes.
5164            let cur_offset: usize = (4 - 1) * envelope_size;
5165
5166            // Zero reserved fields.
5167            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5168
5169            // Safety:
5170            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5171            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5172            //   envelope_size bytes, there is always sufficient room.
5173            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5174                self.connectable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5175                encoder,
5176                offset + cur_offset,
5177                depth,
5178            )?;
5179
5180            _prev_end_offset = cur_offset + envelope_size;
5181            if 5 > max_ordinal {
5182                return Ok(());
5183            }
5184
5185            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5186            // are envelope_size bytes.
5187            let cur_offset: usize = (5 - 1) * envelope_size;
5188
5189            // Zero reserved fields.
5190            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5191
5192            // Safety:
5193            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5194            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5195            //   envelope_size bytes, there is always sufficient room.
5196            fidl::encoding::encode_in_envelope_optional::<ConnectionOptions, D>(
5197                self.connection_options
5198                    .as_ref()
5199                    .map(<ConnectionOptions as fidl::encoding::ValueTypeMarker>::borrow),
5200                encoder,
5201                offset + cur_offset,
5202                depth,
5203            )?;
5204
5205            _prev_end_offset = cur_offset + envelope_size;
5206            if 6 > max_ordinal {
5207                return Ok(());
5208            }
5209
5210            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5211            // are envelope_size bytes.
5212            let cur_offset: usize = (6 - 1) * envelope_size;
5213
5214            // Zero reserved fields.
5215            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5216
5217            // Safety:
5218            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5219            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5220            //   envelope_size bytes, there is always sufficient room.
5221            fidl::encoding::encode_in_envelope_optional::<AdvertisingProcedure, D>(
5222                self.advertising_procedure
5223                    .as_ref()
5224                    .map(<AdvertisingProcedure as fidl::encoding::ValueTypeMarker>::borrow),
5225                encoder,
5226                offset + cur_offset,
5227                depth,
5228            )?;
5229
5230            _prev_end_offset = cur_offset + envelope_size;
5231            if 7 > max_ordinal {
5232                return Ok(());
5233            }
5234
5235            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5236            // are envelope_size bytes.
5237            let cur_offset: usize = (7 - 1) * envelope_size;
5238
5239            // Zero reserved fields.
5240            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5241
5242            // Safety:
5243            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5244            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5245            //   envelope_size bytes, there is always sufficient room.
5246            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::AddressType, D>(
5247            self.address_type.as_ref().map(<fidl_fuchsia_bluetooth__common::AddressType as fidl::encoding::ValueTypeMarker>::borrow),
5248            encoder, offset + cur_offset, depth
5249        )?;
5250
5251            _prev_end_offset = cur_offset + envelope_size;
5252
5253            Ok(())
5254        }
5255    }
5256
5257    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvertisingParameters {
5258        #[inline(always)]
5259        fn new_empty() -> Self {
5260            Self::default()
5261        }
5262
5263        unsafe fn decode(
5264            &mut self,
5265            decoder: &mut fidl::encoding::Decoder<'_, D>,
5266            offset: usize,
5267            mut depth: fidl::encoding::Depth,
5268        ) -> fidl::Result<()> {
5269            decoder.debug_check_bounds::<Self>(offset);
5270            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5271                None => return Err(fidl::Error::NotNullable),
5272                Some(len) => len,
5273            };
5274            // Calling decoder.out_of_line_offset(0) is not allowed.
5275            if len == 0 {
5276                return Ok(());
5277            };
5278            depth.increment()?;
5279            let envelope_size = 8;
5280            let bytes_len = len * envelope_size;
5281            let offset = decoder.out_of_line_offset(bytes_len)?;
5282            // Decode the envelope for each type.
5283            let mut _next_ordinal_to_read = 0;
5284            let mut next_offset = offset;
5285            let end_offset = offset + bytes_len;
5286            _next_ordinal_to_read += 1;
5287            if next_offset >= end_offset {
5288                return Ok(());
5289            }
5290
5291            // Decode unknown envelopes for gaps in ordinals.
5292            while _next_ordinal_to_read < 1 {
5293                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5294                _next_ordinal_to_read += 1;
5295                next_offset += envelope_size;
5296            }
5297
5298            let next_out_of_line = decoder.next_out_of_line();
5299            let handles_before = decoder.remaining_handles();
5300            if let Some((inlined, num_bytes, num_handles)) =
5301                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5302            {
5303                let member_inline_size =
5304                    <AdvertisingData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5305                if inlined != (member_inline_size <= 4) {
5306                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5307                }
5308                let inner_offset;
5309                let mut inner_depth = depth.clone();
5310                if inlined {
5311                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5312                    inner_offset = next_offset;
5313                } else {
5314                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5315                    inner_depth.increment()?;
5316                }
5317                let val_ref = self.data.get_or_insert_with(|| fidl::new_empty!(AdvertisingData, D));
5318                fidl::decode!(AdvertisingData, D, val_ref, decoder, inner_offset, inner_depth)?;
5319                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5320                {
5321                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5322                }
5323                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5324                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5325                }
5326            }
5327
5328            next_offset += envelope_size;
5329            _next_ordinal_to_read += 1;
5330            if next_offset >= end_offset {
5331                return Ok(());
5332            }
5333
5334            // Decode unknown envelopes for gaps in ordinals.
5335            while _next_ordinal_to_read < 2 {
5336                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5337                _next_ordinal_to_read += 1;
5338                next_offset += envelope_size;
5339            }
5340
5341            let next_out_of_line = decoder.next_out_of_line();
5342            let handles_before = decoder.remaining_handles();
5343            if let Some((inlined, num_bytes, num_handles)) =
5344                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5345            {
5346                let member_inline_size =
5347                    <AdvertisingData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5348                if inlined != (member_inline_size <= 4) {
5349                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5350                }
5351                let inner_offset;
5352                let mut inner_depth = depth.clone();
5353                if inlined {
5354                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5355                    inner_offset = next_offset;
5356                } else {
5357                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5358                    inner_depth.increment()?;
5359                }
5360                let val_ref =
5361                    self.scan_response.get_or_insert_with(|| fidl::new_empty!(AdvertisingData, D));
5362                fidl::decode!(AdvertisingData, D, val_ref, decoder, inner_offset, inner_depth)?;
5363                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5364                {
5365                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5366                }
5367                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5368                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5369                }
5370            }
5371
5372            next_offset += envelope_size;
5373            _next_ordinal_to_read += 1;
5374            if next_offset >= end_offset {
5375                return Ok(());
5376            }
5377
5378            // Decode unknown envelopes for gaps in ordinals.
5379            while _next_ordinal_to_read < 3 {
5380                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5381                _next_ordinal_to_read += 1;
5382                next_offset += envelope_size;
5383            }
5384
5385            let next_out_of_line = decoder.next_out_of_line();
5386            let handles_before = decoder.remaining_handles();
5387            if let Some((inlined, num_bytes, num_handles)) =
5388                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5389            {
5390                let member_inline_size =
5391                    <AdvertisingModeHint as fidl::encoding::TypeMarker>::inline_size(
5392                        decoder.context,
5393                    );
5394                if inlined != (member_inline_size <= 4) {
5395                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5396                }
5397                let inner_offset;
5398                let mut inner_depth = depth.clone();
5399                if inlined {
5400                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5401                    inner_offset = next_offset;
5402                } else {
5403                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5404                    inner_depth.increment()?;
5405                }
5406                let val_ref =
5407                    self.mode_hint.get_or_insert_with(|| fidl::new_empty!(AdvertisingModeHint, D));
5408                fidl::decode!(AdvertisingModeHint, D, val_ref, decoder, inner_offset, inner_depth)?;
5409                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5410                {
5411                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5412                }
5413                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5414                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5415                }
5416            }
5417
5418            next_offset += envelope_size;
5419            _next_ordinal_to_read += 1;
5420            if next_offset >= end_offset {
5421                return Ok(());
5422            }
5423
5424            // Decode unknown envelopes for gaps in ordinals.
5425            while _next_ordinal_to_read < 4 {
5426                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5427                _next_ordinal_to_read += 1;
5428                next_offset += envelope_size;
5429            }
5430
5431            let next_out_of_line = decoder.next_out_of_line();
5432            let handles_before = decoder.remaining_handles();
5433            if let Some((inlined, num_bytes, num_handles)) =
5434                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5435            {
5436                let member_inline_size =
5437                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5438                if inlined != (member_inline_size <= 4) {
5439                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5440                }
5441                let inner_offset;
5442                let mut inner_depth = depth.clone();
5443                if inlined {
5444                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5445                    inner_offset = next_offset;
5446                } else {
5447                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5448                    inner_depth.increment()?;
5449                }
5450                let val_ref = self.connectable.get_or_insert_with(|| fidl::new_empty!(bool, D));
5451                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5452                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5453                {
5454                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5455                }
5456                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5457                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5458                }
5459            }
5460
5461            next_offset += envelope_size;
5462            _next_ordinal_to_read += 1;
5463            if next_offset >= end_offset {
5464                return Ok(());
5465            }
5466
5467            // Decode unknown envelopes for gaps in ordinals.
5468            while _next_ordinal_to_read < 5 {
5469                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5470                _next_ordinal_to_read += 1;
5471                next_offset += envelope_size;
5472            }
5473
5474            let next_out_of_line = decoder.next_out_of_line();
5475            let handles_before = decoder.remaining_handles();
5476            if let Some((inlined, num_bytes, num_handles)) =
5477                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5478            {
5479                let member_inline_size =
5480                    <ConnectionOptions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5481                if inlined != (member_inline_size <= 4) {
5482                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5483                }
5484                let inner_offset;
5485                let mut inner_depth = depth.clone();
5486                if inlined {
5487                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5488                    inner_offset = next_offset;
5489                } else {
5490                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5491                    inner_depth.increment()?;
5492                }
5493                let val_ref = self
5494                    .connection_options
5495                    .get_or_insert_with(|| fidl::new_empty!(ConnectionOptions, D));
5496                fidl::decode!(ConnectionOptions, D, val_ref, decoder, inner_offset, inner_depth)?;
5497                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5498                {
5499                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5500                }
5501                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5502                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5503                }
5504            }
5505
5506            next_offset += envelope_size;
5507            _next_ordinal_to_read += 1;
5508            if next_offset >= end_offset {
5509                return Ok(());
5510            }
5511
5512            // Decode unknown envelopes for gaps in ordinals.
5513            while _next_ordinal_to_read < 6 {
5514                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5515                _next_ordinal_to_read += 1;
5516                next_offset += envelope_size;
5517            }
5518
5519            let next_out_of_line = decoder.next_out_of_line();
5520            let handles_before = decoder.remaining_handles();
5521            if let Some((inlined, num_bytes, num_handles)) =
5522                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5523            {
5524                let member_inline_size =
5525                    <AdvertisingProcedure as fidl::encoding::TypeMarker>::inline_size(
5526                        decoder.context,
5527                    );
5528                if inlined != (member_inline_size <= 4) {
5529                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5530                }
5531                let inner_offset;
5532                let mut inner_depth = depth.clone();
5533                if inlined {
5534                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5535                    inner_offset = next_offset;
5536                } else {
5537                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5538                    inner_depth.increment()?;
5539                }
5540                let val_ref = self
5541                    .advertising_procedure
5542                    .get_or_insert_with(|| fidl::new_empty!(AdvertisingProcedure, D));
5543                fidl::decode!(
5544                    AdvertisingProcedure,
5545                    D,
5546                    val_ref,
5547                    decoder,
5548                    inner_offset,
5549                    inner_depth
5550                )?;
5551                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5552                {
5553                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5554                }
5555                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5556                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5557                }
5558            }
5559
5560            next_offset += envelope_size;
5561            _next_ordinal_to_read += 1;
5562            if next_offset >= end_offset {
5563                return Ok(());
5564            }
5565
5566            // Decode unknown envelopes for gaps in ordinals.
5567            while _next_ordinal_to_read < 7 {
5568                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5569                _next_ordinal_to_read += 1;
5570                next_offset += envelope_size;
5571            }
5572
5573            let next_out_of_line = decoder.next_out_of_line();
5574            let handles_before = decoder.remaining_handles();
5575            if let Some((inlined, num_bytes, num_handles)) =
5576                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5577            {
5578                let member_inline_size = <fidl_fuchsia_bluetooth__common::AddressType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5579                if inlined != (member_inline_size <= 4) {
5580                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5581                }
5582                let inner_offset;
5583                let mut inner_depth = depth.clone();
5584                if inlined {
5585                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5586                    inner_offset = next_offset;
5587                } else {
5588                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5589                    inner_depth.increment()?;
5590                }
5591                let val_ref = self.address_type.get_or_insert_with(|| {
5592                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::AddressType, D)
5593                });
5594                fidl::decode!(
5595                    fidl_fuchsia_bluetooth__common::AddressType,
5596                    D,
5597                    val_ref,
5598                    decoder,
5599                    inner_offset,
5600                    inner_depth
5601                )?;
5602                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5603                {
5604                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5605                }
5606                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5607                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5608                }
5609            }
5610
5611            next_offset += envelope_size;
5612
5613            // Decode the remaining unknown envelopes.
5614            while next_offset < end_offset {
5615                _next_ordinal_to_read += 1;
5616                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5617                next_offset += envelope_size;
5618            }
5619
5620            Ok(())
5621        }
5622    }
5623
5624    impl CentralCreateConnectedIsochronousGroupResponse {
5625        #[inline(always)]
5626        fn max_ordinal_present(&self) -> u64 {
5627            if let Some(_) = self.cig_id {
5628                return 1;
5629            }
5630            0
5631        }
5632    }
5633
5634    impl fidl::encoding::ValueTypeMarker for CentralCreateConnectedIsochronousGroupResponse {
5635        type Borrowed<'a> = &'a Self;
5636        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5637            value
5638        }
5639    }
5640
5641    unsafe impl fidl::encoding::TypeMarker for CentralCreateConnectedIsochronousGroupResponse {
5642        type Owned = Self;
5643
5644        #[inline(always)]
5645        fn inline_align(_context: fidl::encoding::Context) -> usize {
5646            8
5647        }
5648
5649        #[inline(always)]
5650        fn inline_size(_context: fidl::encoding::Context) -> usize {
5651            16
5652        }
5653    }
5654
5655    unsafe impl<D: fidl::encoding::ResourceDialect>
5656        fidl::encoding::Encode<CentralCreateConnectedIsochronousGroupResponse, D>
5657        for &CentralCreateConnectedIsochronousGroupResponse
5658    {
5659        unsafe fn encode(
5660            self,
5661            encoder: &mut fidl::encoding::Encoder<'_, D>,
5662            offset: usize,
5663            mut depth: fidl::encoding::Depth,
5664        ) -> fidl::Result<()> {
5665            encoder.debug_check_bounds::<CentralCreateConnectedIsochronousGroupResponse>(offset);
5666            // Vector header
5667            let max_ordinal: u64 = self.max_ordinal_present();
5668            encoder.write_num(max_ordinal, offset);
5669            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5670            // Calling encoder.out_of_line_offset(0) is not allowed.
5671            if max_ordinal == 0 {
5672                return Ok(());
5673            }
5674            depth.increment()?;
5675            let envelope_size = 8;
5676            let bytes_len = max_ordinal as usize * envelope_size;
5677            #[allow(unused_variables)]
5678            let offset = encoder.out_of_line_offset(bytes_len);
5679            let mut _prev_end_offset: usize = 0;
5680            if 1 > max_ordinal {
5681                return Ok(());
5682            }
5683
5684            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5685            // are envelope_size bytes.
5686            let cur_offset: usize = (1 - 1) * envelope_size;
5687
5688            // Zero reserved fields.
5689            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5690
5691            // Safety:
5692            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5693            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5694            //   envelope_size bytes, there is always sufficient room.
5695            fidl::encoding::encode_in_envelope_optional::<u8, D>(
5696                self.cig_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
5697                encoder,
5698                offset + cur_offset,
5699                depth,
5700            )?;
5701
5702            _prev_end_offset = cur_offset + envelope_size;
5703
5704            Ok(())
5705        }
5706    }
5707
5708    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5709        for CentralCreateConnectedIsochronousGroupResponse
5710    {
5711        #[inline(always)]
5712        fn new_empty() -> Self {
5713            Self::default()
5714        }
5715
5716        unsafe fn decode(
5717            &mut self,
5718            decoder: &mut fidl::encoding::Decoder<'_, D>,
5719            offset: usize,
5720            mut depth: fidl::encoding::Depth,
5721        ) -> fidl::Result<()> {
5722            decoder.debug_check_bounds::<Self>(offset);
5723            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5724                None => return Err(fidl::Error::NotNullable),
5725                Some(len) => len,
5726            };
5727            // Calling decoder.out_of_line_offset(0) is not allowed.
5728            if len == 0 {
5729                return Ok(());
5730            };
5731            depth.increment()?;
5732            let envelope_size = 8;
5733            let bytes_len = len * envelope_size;
5734            let offset = decoder.out_of_line_offset(bytes_len)?;
5735            // Decode the envelope for each type.
5736            let mut _next_ordinal_to_read = 0;
5737            let mut next_offset = offset;
5738            let end_offset = offset + bytes_len;
5739            _next_ordinal_to_read += 1;
5740            if next_offset >= end_offset {
5741                return Ok(());
5742            }
5743
5744            // Decode unknown envelopes for gaps in ordinals.
5745            while _next_ordinal_to_read < 1 {
5746                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5747                _next_ordinal_to_read += 1;
5748                next_offset += envelope_size;
5749            }
5750
5751            let next_out_of_line = decoder.next_out_of_line();
5752            let handles_before = decoder.remaining_handles();
5753            if let Some((inlined, num_bytes, num_handles)) =
5754                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5755            {
5756                let member_inline_size =
5757                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5758                if inlined != (member_inline_size <= 4) {
5759                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5760                }
5761                let inner_offset;
5762                let mut inner_depth = depth.clone();
5763                if inlined {
5764                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5765                    inner_offset = next_offset;
5766                } else {
5767                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5768                    inner_depth.increment()?;
5769                }
5770                let val_ref = self.cig_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
5771                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
5772                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5773                {
5774                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5775                }
5776                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5777                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5778                }
5779            }
5780
5781            next_offset += envelope_size;
5782
5783            // Decode the remaining unknown envelopes.
5784            while next_offset < end_offset {
5785                _next_ordinal_to_read += 1;
5786                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5787                next_offset += envelope_size;
5788            }
5789
5790            Ok(())
5791        }
5792    }
5793
5794    impl ChannelListenerRegistryListenL2capResponse {
5795        #[inline(always)]
5796        fn max_ordinal_present(&self) -> u64 {
5797            if let Some(_) = self.psm {
5798                return 1;
5799            }
5800            0
5801        }
5802    }
5803
5804    impl fidl::encoding::ValueTypeMarker for ChannelListenerRegistryListenL2capResponse {
5805        type Borrowed<'a> = &'a Self;
5806        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5807            value
5808        }
5809    }
5810
5811    unsafe impl fidl::encoding::TypeMarker for ChannelListenerRegistryListenL2capResponse {
5812        type Owned = Self;
5813
5814        #[inline(always)]
5815        fn inline_align(_context: fidl::encoding::Context) -> usize {
5816            8
5817        }
5818
5819        #[inline(always)]
5820        fn inline_size(_context: fidl::encoding::Context) -> usize {
5821            16
5822        }
5823    }
5824
5825    unsafe impl<D: fidl::encoding::ResourceDialect>
5826        fidl::encoding::Encode<ChannelListenerRegistryListenL2capResponse, D>
5827        for &ChannelListenerRegistryListenL2capResponse
5828    {
5829        unsafe fn encode(
5830            self,
5831            encoder: &mut fidl::encoding::Encoder<'_, D>,
5832            offset: usize,
5833            mut depth: fidl::encoding::Depth,
5834        ) -> fidl::Result<()> {
5835            encoder.debug_check_bounds::<ChannelListenerRegistryListenL2capResponse>(offset);
5836            // Vector header
5837            let max_ordinal: u64 = self.max_ordinal_present();
5838            encoder.write_num(max_ordinal, offset);
5839            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5840            // Calling encoder.out_of_line_offset(0) is not allowed.
5841            if max_ordinal == 0 {
5842                return Ok(());
5843            }
5844            depth.increment()?;
5845            let envelope_size = 8;
5846            let bytes_len = max_ordinal as usize * envelope_size;
5847            #[allow(unused_variables)]
5848            let offset = encoder.out_of_line_offset(bytes_len);
5849            let mut _prev_end_offset: usize = 0;
5850            if 1 > max_ordinal {
5851                return Ok(());
5852            }
5853
5854            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5855            // are envelope_size bytes.
5856            let cur_offset: usize = (1 - 1) * envelope_size;
5857
5858            // Zero reserved fields.
5859            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5860
5861            // Safety:
5862            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5863            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5864            //   envelope_size bytes, there is always sufficient room.
5865            fidl::encoding::encode_in_envelope_optional::<u16, D>(
5866                self.psm.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5867                encoder,
5868                offset + cur_offset,
5869                depth,
5870            )?;
5871
5872            _prev_end_offset = cur_offset + envelope_size;
5873
5874            Ok(())
5875        }
5876    }
5877
5878    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
5879        for ChannelListenerRegistryListenL2capResponse
5880    {
5881        #[inline(always)]
5882        fn new_empty() -> Self {
5883            Self::default()
5884        }
5885
5886        unsafe fn decode(
5887            &mut self,
5888            decoder: &mut fidl::encoding::Decoder<'_, D>,
5889            offset: usize,
5890            mut depth: fidl::encoding::Depth,
5891        ) -> fidl::Result<()> {
5892            decoder.debug_check_bounds::<Self>(offset);
5893            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5894                None => return Err(fidl::Error::NotNullable),
5895                Some(len) => len,
5896            };
5897            // Calling decoder.out_of_line_offset(0) is not allowed.
5898            if len == 0 {
5899                return Ok(());
5900            };
5901            depth.increment()?;
5902            let envelope_size = 8;
5903            let bytes_len = len * envelope_size;
5904            let offset = decoder.out_of_line_offset(bytes_len)?;
5905            // Decode the envelope for each type.
5906            let mut _next_ordinal_to_read = 0;
5907            let mut next_offset = offset;
5908            let end_offset = offset + bytes_len;
5909            _next_ordinal_to_read += 1;
5910            if next_offset >= end_offset {
5911                return Ok(());
5912            }
5913
5914            // Decode unknown envelopes for gaps in ordinals.
5915            while _next_ordinal_to_read < 1 {
5916                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5917                _next_ordinal_to_read += 1;
5918                next_offset += envelope_size;
5919            }
5920
5921            let next_out_of_line = decoder.next_out_of_line();
5922            let handles_before = decoder.remaining_handles();
5923            if let Some((inlined, num_bytes, num_handles)) =
5924                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5925            {
5926                let member_inline_size =
5927                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5928                if inlined != (member_inline_size <= 4) {
5929                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5930                }
5931                let inner_offset;
5932                let mut inner_depth = depth.clone();
5933                if inlined {
5934                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5935                    inner_offset = next_offset;
5936                } else {
5937                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5938                    inner_depth.increment()?;
5939                }
5940                let val_ref = self.psm.get_or_insert_with(|| fidl::new_empty!(u16, D));
5941                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5942                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5943                {
5944                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5945                }
5946                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5947                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5948                }
5949            }
5950
5951            next_offset += envelope_size;
5952
5953            // Decode the remaining unknown envelopes.
5954            while next_offset < end_offset {
5955                _next_ordinal_to_read += 1;
5956                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5957                next_offset += envelope_size;
5958            }
5959
5960            Ok(())
5961        }
5962    }
5963
5964    impl CigParameters {
5965        #[inline(always)]
5966        fn max_ordinal_present(&self) -> u64 {
5967            if let Some(_) = self.max_transport_latency_p_to_c {
5968                return 6;
5969            }
5970            if let Some(_) = self.max_transport_latency_c_to_p {
5971                return 5;
5972            }
5973            if let Some(_) = self.framing {
5974                return 4;
5975            }
5976            if let Some(_) = self.packing {
5977                return 3;
5978            }
5979            if let Some(_) = self.sdu_interval_p_to_c {
5980                return 2;
5981            }
5982            if let Some(_) = self.sdu_interval_c_to_p {
5983                return 1;
5984            }
5985            0
5986        }
5987    }
5988
5989    impl fidl::encoding::ValueTypeMarker for CigParameters {
5990        type Borrowed<'a> = &'a Self;
5991        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5992            value
5993        }
5994    }
5995
5996    unsafe impl fidl::encoding::TypeMarker for CigParameters {
5997        type Owned = Self;
5998
5999        #[inline(always)]
6000        fn inline_align(_context: fidl::encoding::Context) -> usize {
6001            8
6002        }
6003
6004        #[inline(always)]
6005        fn inline_size(_context: fidl::encoding::Context) -> usize {
6006            16
6007        }
6008    }
6009
6010    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CigParameters, D>
6011        for &CigParameters
6012    {
6013        unsafe fn encode(
6014            self,
6015            encoder: &mut fidl::encoding::Encoder<'_, D>,
6016            offset: usize,
6017            mut depth: fidl::encoding::Depth,
6018        ) -> fidl::Result<()> {
6019            encoder.debug_check_bounds::<CigParameters>(offset);
6020            // Vector header
6021            let max_ordinal: u64 = self.max_ordinal_present();
6022            encoder.write_num(max_ordinal, offset);
6023            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6024            // Calling encoder.out_of_line_offset(0) is not allowed.
6025            if max_ordinal == 0 {
6026                return Ok(());
6027            }
6028            depth.increment()?;
6029            let envelope_size = 8;
6030            let bytes_len = max_ordinal as usize * envelope_size;
6031            #[allow(unused_variables)]
6032            let offset = encoder.out_of_line_offset(bytes_len);
6033            let mut _prev_end_offset: usize = 0;
6034            if 1 > max_ordinal {
6035                return Ok(());
6036            }
6037
6038            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6039            // are envelope_size bytes.
6040            let cur_offset: usize = (1 - 1) * envelope_size;
6041
6042            // Zero reserved fields.
6043            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6044
6045            // Safety:
6046            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6047            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6048            //   envelope_size bytes, there is always sufficient room.
6049            fidl::encoding::encode_in_envelope_optional::<u32, D>(
6050                self.sdu_interval_c_to_p
6051                    .as_ref()
6052                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6053                encoder,
6054                offset + cur_offset,
6055                depth,
6056            )?;
6057
6058            _prev_end_offset = cur_offset + envelope_size;
6059            if 2 > max_ordinal {
6060                return Ok(());
6061            }
6062
6063            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6064            // are envelope_size bytes.
6065            let cur_offset: usize = (2 - 1) * envelope_size;
6066
6067            // Zero reserved fields.
6068            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6069
6070            // Safety:
6071            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6072            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6073            //   envelope_size bytes, there is always sufficient room.
6074            fidl::encoding::encode_in_envelope_optional::<u32, D>(
6075                self.sdu_interval_p_to_c
6076                    .as_ref()
6077                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6078                encoder,
6079                offset + cur_offset,
6080                depth,
6081            )?;
6082
6083            _prev_end_offset = cur_offset + envelope_size;
6084            if 3 > max_ordinal {
6085                return Ok(());
6086            }
6087
6088            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6089            // are envelope_size bytes.
6090            let cur_offset: usize = (3 - 1) * envelope_size;
6091
6092            // Zero reserved fields.
6093            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6094
6095            // Safety:
6096            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6097            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6098            //   envelope_size bytes, there is always sufficient room.
6099            fidl::encoding::encode_in_envelope_optional::<CigPacking, D>(
6100                self.packing.as_ref().map(<CigPacking as fidl::encoding::ValueTypeMarker>::borrow),
6101                encoder,
6102                offset + cur_offset,
6103                depth,
6104            )?;
6105
6106            _prev_end_offset = cur_offset + envelope_size;
6107            if 4 > max_ordinal {
6108                return Ok(());
6109            }
6110
6111            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6112            // are envelope_size bytes.
6113            let cur_offset: usize = (4 - 1) * envelope_size;
6114
6115            // Zero reserved fields.
6116            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6117
6118            // Safety:
6119            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6120            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6121            //   envelope_size bytes, there is always sufficient room.
6122            fidl::encoding::encode_in_envelope_optional::<CigFramingOptions, D>(
6123                self.framing
6124                    .as_ref()
6125                    .map(<CigFramingOptions as fidl::encoding::ValueTypeMarker>::borrow),
6126                encoder,
6127                offset + cur_offset,
6128                depth,
6129            )?;
6130
6131            _prev_end_offset = cur_offset + envelope_size;
6132            if 5 > max_ordinal {
6133                return Ok(());
6134            }
6135
6136            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6137            // are envelope_size bytes.
6138            let cur_offset: usize = (5 - 1) * envelope_size;
6139
6140            // Zero reserved fields.
6141            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6142
6143            // Safety:
6144            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6145            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6146            //   envelope_size bytes, there is always sufficient room.
6147            fidl::encoding::encode_in_envelope_optional::<u16, D>(
6148                self.max_transport_latency_c_to_p
6149                    .as_ref()
6150                    .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
6151                encoder,
6152                offset + cur_offset,
6153                depth,
6154            )?;
6155
6156            _prev_end_offset = cur_offset + envelope_size;
6157            if 6 > max_ordinal {
6158                return Ok(());
6159            }
6160
6161            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6162            // are envelope_size bytes.
6163            let cur_offset: usize = (6 - 1) * envelope_size;
6164
6165            // Zero reserved fields.
6166            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6167
6168            // Safety:
6169            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6170            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6171            //   envelope_size bytes, there is always sufficient room.
6172            fidl::encoding::encode_in_envelope_optional::<u16, D>(
6173                self.max_transport_latency_p_to_c
6174                    .as_ref()
6175                    .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
6176                encoder,
6177                offset + cur_offset,
6178                depth,
6179            )?;
6180
6181            _prev_end_offset = cur_offset + envelope_size;
6182
6183            Ok(())
6184        }
6185    }
6186
6187    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CigParameters {
6188        #[inline(always)]
6189        fn new_empty() -> Self {
6190            Self::default()
6191        }
6192
6193        unsafe fn decode(
6194            &mut self,
6195            decoder: &mut fidl::encoding::Decoder<'_, D>,
6196            offset: usize,
6197            mut depth: fidl::encoding::Depth,
6198        ) -> fidl::Result<()> {
6199            decoder.debug_check_bounds::<Self>(offset);
6200            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6201                None => return Err(fidl::Error::NotNullable),
6202                Some(len) => len,
6203            };
6204            // Calling decoder.out_of_line_offset(0) is not allowed.
6205            if len == 0 {
6206                return Ok(());
6207            };
6208            depth.increment()?;
6209            let envelope_size = 8;
6210            let bytes_len = len * envelope_size;
6211            let offset = decoder.out_of_line_offset(bytes_len)?;
6212            // Decode the envelope for each type.
6213            let mut _next_ordinal_to_read = 0;
6214            let mut next_offset = offset;
6215            let end_offset = offset + bytes_len;
6216            _next_ordinal_to_read += 1;
6217            if next_offset >= end_offset {
6218                return Ok(());
6219            }
6220
6221            // Decode unknown envelopes for gaps in ordinals.
6222            while _next_ordinal_to_read < 1 {
6223                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6224                _next_ordinal_to_read += 1;
6225                next_offset += envelope_size;
6226            }
6227
6228            let next_out_of_line = decoder.next_out_of_line();
6229            let handles_before = decoder.remaining_handles();
6230            if let Some((inlined, num_bytes, num_handles)) =
6231                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6232            {
6233                let member_inline_size =
6234                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6235                if inlined != (member_inline_size <= 4) {
6236                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6237                }
6238                let inner_offset;
6239                let mut inner_depth = depth.clone();
6240                if inlined {
6241                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6242                    inner_offset = next_offset;
6243                } else {
6244                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6245                    inner_depth.increment()?;
6246                }
6247                let val_ref =
6248                    self.sdu_interval_c_to_p.get_or_insert_with(|| fidl::new_empty!(u32, D));
6249                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6250                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6251                {
6252                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6253                }
6254                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6255                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6256                }
6257            }
6258
6259            next_offset += envelope_size;
6260            _next_ordinal_to_read += 1;
6261            if next_offset >= end_offset {
6262                return Ok(());
6263            }
6264
6265            // Decode unknown envelopes for gaps in ordinals.
6266            while _next_ordinal_to_read < 2 {
6267                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6268                _next_ordinal_to_read += 1;
6269                next_offset += envelope_size;
6270            }
6271
6272            let next_out_of_line = decoder.next_out_of_line();
6273            let handles_before = decoder.remaining_handles();
6274            if let Some((inlined, num_bytes, num_handles)) =
6275                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6276            {
6277                let member_inline_size =
6278                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6279                if inlined != (member_inline_size <= 4) {
6280                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6281                }
6282                let inner_offset;
6283                let mut inner_depth = depth.clone();
6284                if inlined {
6285                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6286                    inner_offset = next_offset;
6287                } else {
6288                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6289                    inner_depth.increment()?;
6290                }
6291                let val_ref =
6292                    self.sdu_interval_p_to_c.get_or_insert_with(|| fidl::new_empty!(u32, D));
6293                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6294                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6295                {
6296                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6297                }
6298                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6299                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6300                }
6301            }
6302
6303            next_offset += envelope_size;
6304            _next_ordinal_to_read += 1;
6305            if next_offset >= end_offset {
6306                return Ok(());
6307            }
6308
6309            // Decode unknown envelopes for gaps in ordinals.
6310            while _next_ordinal_to_read < 3 {
6311                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6312                _next_ordinal_to_read += 1;
6313                next_offset += envelope_size;
6314            }
6315
6316            let next_out_of_line = decoder.next_out_of_line();
6317            let handles_before = decoder.remaining_handles();
6318            if let Some((inlined, num_bytes, num_handles)) =
6319                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6320            {
6321                let member_inline_size =
6322                    <CigPacking as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6323                if inlined != (member_inline_size <= 4) {
6324                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6325                }
6326                let inner_offset;
6327                let mut inner_depth = depth.clone();
6328                if inlined {
6329                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6330                    inner_offset = next_offset;
6331                } else {
6332                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6333                    inner_depth.increment()?;
6334                }
6335                let val_ref = self.packing.get_or_insert_with(|| fidl::new_empty!(CigPacking, D));
6336                fidl::decode!(CigPacking, D, val_ref, decoder, inner_offset, inner_depth)?;
6337                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6338                {
6339                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6340                }
6341                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6342                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6343                }
6344            }
6345
6346            next_offset += envelope_size;
6347            _next_ordinal_to_read += 1;
6348            if next_offset >= end_offset {
6349                return Ok(());
6350            }
6351
6352            // Decode unknown envelopes for gaps in ordinals.
6353            while _next_ordinal_to_read < 4 {
6354                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6355                _next_ordinal_to_read += 1;
6356                next_offset += envelope_size;
6357            }
6358
6359            let next_out_of_line = decoder.next_out_of_line();
6360            let handles_before = decoder.remaining_handles();
6361            if let Some((inlined, num_bytes, num_handles)) =
6362                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6363            {
6364                let member_inline_size =
6365                    <CigFramingOptions as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6366                if inlined != (member_inline_size <= 4) {
6367                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6368                }
6369                let inner_offset;
6370                let mut inner_depth = depth.clone();
6371                if inlined {
6372                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6373                    inner_offset = next_offset;
6374                } else {
6375                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6376                    inner_depth.increment()?;
6377                }
6378                let val_ref =
6379                    self.framing.get_or_insert_with(|| fidl::new_empty!(CigFramingOptions, D));
6380                fidl::decode!(CigFramingOptions, D, val_ref, decoder, inner_offset, inner_depth)?;
6381                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6382                {
6383                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6384                }
6385                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6386                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6387                }
6388            }
6389
6390            next_offset += envelope_size;
6391            _next_ordinal_to_read += 1;
6392            if next_offset >= end_offset {
6393                return Ok(());
6394            }
6395
6396            // Decode unknown envelopes for gaps in ordinals.
6397            while _next_ordinal_to_read < 5 {
6398                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6399                _next_ordinal_to_read += 1;
6400                next_offset += envelope_size;
6401            }
6402
6403            let next_out_of_line = decoder.next_out_of_line();
6404            let handles_before = decoder.remaining_handles();
6405            if let Some((inlined, num_bytes, num_handles)) =
6406                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6407            {
6408                let member_inline_size =
6409                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6410                if inlined != (member_inline_size <= 4) {
6411                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6412                }
6413                let inner_offset;
6414                let mut inner_depth = depth.clone();
6415                if inlined {
6416                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6417                    inner_offset = next_offset;
6418                } else {
6419                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6420                    inner_depth.increment()?;
6421                }
6422                let val_ref = self
6423                    .max_transport_latency_c_to_p
6424                    .get_or_insert_with(|| fidl::new_empty!(u16, D));
6425                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6426                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6427                {
6428                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6429                }
6430                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6431                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6432                }
6433            }
6434
6435            next_offset += envelope_size;
6436            _next_ordinal_to_read += 1;
6437            if next_offset >= end_offset {
6438                return Ok(());
6439            }
6440
6441            // Decode unknown envelopes for gaps in ordinals.
6442            while _next_ordinal_to_read < 6 {
6443                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6444                _next_ordinal_to_read += 1;
6445                next_offset += envelope_size;
6446            }
6447
6448            let next_out_of_line = decoder.next_out_of_line();
6449            let handles_before = decoder.remaining_handles();
6450            if let Some((inlined, num_bytes, num_handles)) =
6451                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6452            {
6453                let member_inline_size =
6454                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6455                if inlined != (member_inline_size <= 4) {
6456                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6457                }
6458                let inner_offset;
6459                let mut inner_depth = depth.clone();
6460                if inlined {
6461                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6462                    inner_offset = next_offset;
6463                } else {
6464                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6465                    inner_depth.increment()?;
6466                }
6467                let val_ref = self
6468                    .max_transport_latency_p_to_c
6469                    .get_or_insert_with(|| fidl::new_empty!(u16, D));
6470                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
6471                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6472                {
6473                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6474                }
6475                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6476                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6477                }
6478            }
6479
6480            next_offset += envelope_size;
6481
6482            // Decode the remaining unknown envelopes.
6483            while next_offset < end_offset {
6484                _next_ordinal_to_read += 1;
6485                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6486                next_offset += envelope_size;
6487            }
6488
6489            Ok(())
6490        }
6491    }
6492
6493    impl CisEstablishedParameters {
6494        #[inline(always)]
6495        fn max_ordinal_present(&self) -> u64 {
6496            if let Some(_) = self.peripheral_to_central_params {
6497                return 6;
6498            }
6499            if let Some(_) = self.central_to_peripheral_params {
6500                return 5;
6501            }
6502            if let Some(_) = self.iso_interval {
6503                return 4;
6504            }
6505            if let Some(_) = self.max_subevents {
6506                return 3;
6507            }
6508            if let Some(_) = self.cis_sync_delay {
6509                return 2;
6510            }
6511            if let Some(_) = self.cig_sync_delay {
6512                return 1;
6513            }
6514            0
6515        }
6516    }
6517
6518    impl fidl::encoding::ValueTypeMarker for CisEstablishedParameters {
6519        type Borrowed<'a> = &'a Self;
6520        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6521            value
6522        }
6523    }
6524
6525    unsafe impl fidl::encoding::TypeMarker for CisEstablishedParameters {
6526        type Owned = Self;
6527
6528        #[inline(always)]
6529        fn inline_align(_context: fidl::encoding::Context) -> usize {
6530            8
6531        }
6532
6533        #[inline(always)]
6534        fn inline_size(_context: fidl::encoding::Context) -> usize {
6535            16
6536        }
6537    }
6538
6539    unsafe impl<D: fidl::encoding::ResourceDialect>
6540        fidl::encoding::Encode<CisEstablishedParameters, D> for &CisEstablishedParameters
6541    {
6542        unsafe fn encode(
6543            self,
6544            encoder: &mut fidl::encoding::Encoder<'_, D>,
6545            offset: usize,
6546            mut depth: fidl::encoding::Depth,
6547        ) -> fidl::Result<()> {
6548            encoder.debug_check_bounds::<CisEstablishedParameters>(offset);
6549            // Vector header
6550            let max_ordinal: u64 = self.max_ordinal_present();
6551            encoder.write_num(max_ordinal, offset);
6552            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6553            // Calling encoder.out_of_line_offset(0) is not allowed.
6554            if max_ordinal == 0 {
6555                return Ok(());
6556            }
6557            depth.increment()?;
6558            let envelope_size = 8;
6559            let bytes_len = max_ordinal as usize * envelope_size;
6560            #[allow(unused_variables)]
6561            let offset = encoder.out_of_line_offset(bytes_len);
6562            let mut _prev_end_offset: usize = 0;
6563            if 1 > max_ordinal {
6564                return Ok(());
6565            }
6566
6567            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6568            // are envelope_size bytes.
6569            let cur_offset: usize = (1 - 1) * envelope_size;
6570
6571            // Zero reserved fields.
6572            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6573
6574            // Safety:
6575            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6576            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6577            //   envelope_size bytes, there is always sufficient room.
6578            fidl::encoding::encode_in_envelope_optional::<i64, D>(
6579                self.cig_sync_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
6580                encoder,
6581                offset + cur_offset,
6582                depth,
6583            )?;
6584
6585            _prev_end_offset = cur_offset + envelope_size;
6586            if 2 > max_ordinal {
6587                return Ok(());
6588            }
6589
6590            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6591            // are envelope_size bytes.
6592            let cur_offset: usize = (2 - 1) * envelope_size;
6593
6594            // Zero reserved fields.
6595            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6596
6597            // Safety:
6598            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6599            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6600            //   envelope_size bytes, there is always sufficient room.
6601            fidl::encoding::encode_in_envelope_optional::<i64, D>(
6602                self.cis_sync_delay.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
6603                encoder,
6604                offset + cur_offset,
6605                depth,
6606            )?;
6607
6608            _prev_end_offset = cur_offset + envelope_size;
6609            if 3 > max_ordinal {
6610                return Ok(());
6611            }
6612
6613            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6614            // are envelope_size bytes.
6615            let cur_offset: usize = (3 - 1) * envelope_size;
6616
6617            // Zero reserved fields.
6618            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6619
6620            // Safety:
6621            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6622            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6623            //   envelope_size bytes, there is always sufficient room.
6624            fidl::encoding::encode_in_envelope_optional::<u8, D>(
6625                self.max_subevents.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
6626                encoder,
6627                offset + cur_offset,
6628                depth,
6629            )?;
6630
6631            _prev_end_offset = cur_offset + envelope_size;
6632            if 4 > max_ordinal {
6633                return Ok(());
6634            }
6635
6636            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6637            // are envelope_size bytes.
6638            let cur_offset: usize = (4 - 1) * envelope_size;
6639
6640            // Zero reserved fields.
6641            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6642
6643            // Safety:
6644            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6645            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6646            //   envelope_size bytes, there is always sufficient room.
6647            fidl::encoding::encode_in_envelope_optional::<i64, D>(
6648                self.iso_interval.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
6649                encoder,
6650                offset + cur_offset,
6651                depth,
6652            )?;
6653
6654            _prev_end_offset = cur_offset + envelope_size;
6655            if 5 > max_ordinal {
6656                return Ok(());
6657            }
6658
6659            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6660            // are envelope_size bytes.
6661            let cur_offset: usize = (5 - 1) * envelope_size;
6662
6663            // Zero reserved fields.
6664            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6665
6666            // Safety:
6667            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6668            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6669            //   envelope_size bytes, there is always sufficient room.
6670            fidl::encoding::encode_in_envelope_optional::<CisUnidirectionalParams, D>(
6671                self.central_to_peripheral_params
6672                    .as_ref()
6673                    .map(<CisUnidirectionalParams 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 6 > 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 = (6 - 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::<CisUnidirectionalParams, D>(
6696                self.peripheral_to_central_params
6697                    .as_ref()
6698                    .map(<CisUnidirectionalParams as fidl::encoding::ValueTypeMarker>::borrow),
6699                encoder,
6700                offset + cur_offset,
6701                depth,
6702            )?;
6703
6704            _prev_end_offset = cur_offset + envelope_size;
6705
6706            Ok(())
6707        }
6708    }
6709
6710    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6711        for CisEstablishedParameters
6712    {
6713        #[inline(always)]
6714        fn new_empty() -> Self {
6715            Self::default()
6716        }
6717
6718        unsafe fn decode(
6719            &mut self,
6720            decoder: &mut fidl::encoding::Decoder<'_, D>,
6721            offset: usize,
6722            mut depth: fidl::encoding::Depth,
6723        ) -> fidl::Result<()> {
6724            decoder.debug_check_bounds::<Self>(offset);
6725            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6726                None => return Err(fidl::Error::NotNullable),
6727                Some(len) => len,
6728            };
6729            // Calling decoder.out_of_line_offset(0) is not allowed.
6730            if len == 0 {
6731                return Ok(());
6732            };
6733            depth.increment()?;
6734            let envelope_size = 8;
6735            let bytes_len = len * envelope_size;
6736            let offset = decoder.out_of_line_offset(bytes_len)?;
6737            // Decode the envelope for each type.
6738            let mut _next_ordinal_to_read = 0;
6739            let mut next_offset = offset;
6740            let end_offset = offset + bytes_len;
6741            _next_ordinal_to_read += 1;
6742            if next_offset >= end_offset {
6743                return Ok(());
6744            }
6745
6746            // Decode unknown envelopes for gaps in ordinals.
6747            while _next_ordinal_to_read < 1 {
6748                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6749                _next_ordinal_to_read += 1;
6750                next_offset += envelope_size;
6751            }
6752
6753            let next_out_of_line = decoder.next_out_of_line();
6754            let handles_before = decoder.remaining_handles();
6755            if let Some((inlined, num_bytes, num_handles)) =
6756                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6757            {
6758                let member_inline_size =
6759                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6760                if inlined != (member_inline_size <= 4) {
6761                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6762                }
6763                let inner_offset;
6764                let mut inner_depth = depth.clone();
6765                if inlined {
6766                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6767                    inner_offset = next_offset;
6768                } else {
6769                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6770                    inner_depth.increment()?;
6771                }
6772                let val_ref = self.cig_sync_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
6773                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6774                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6775                {
6776                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6777                }
6778                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6779                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6780                }
6781            }
6782
6783            next_offset += envelope_size;
6784            _next_ordinal_to_read += 1;
6785            if next_offset >= end_offset {
6786                return Ok(());
6787            }
6788
6789            // Decode unknown envelopes for gaps in ordinals.
6790            while _next_ordinal_to_read < 2 {
6791                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6792                _next_ordinal_to_read += 1;
6793                next_offset += envelope_size;
6794            }
6795
6796            let next_out_of_line = decoder.next_out_of_line();
6797            let handles_before = decoder.remaining_handles();
6798            if let Some((inlined, num_bytes, num_handles)) =
6799                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6800            {
6801                let member_inline_size =
6802                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6803                if inlined != (member_inline_size <= 4) {
6804                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6805                }
6806                let inner_offset;
6807                let mut inner_depth = depth.clone();
6808                if inlined {
6809                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6810                    inner_offset = next_offset;
6811                } else {
6812                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6813                    inner_depth.increment()?;
6814                }
6815                let val_ref = self.cis_sync_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
6816                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6817                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6818                {
6819                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6820                }
6821                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6822                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6823                }
6824            }
6825
6826            next_offset += envelope_size;
6827            _next_ordinal_to_read += 1;
6828            if next_offset >= end_offset {
6829                return Ok(());
6830            }
6831
6832            // Decode unknown envelopes for gaps in ordinals.
6833            while _next_ordinal_to_read < 3 {
6834                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6835                _next_ordinal_to_read += 1;
6836                next_offset += envelope_size;
6837            }
6838
6839            let next_out_of_line = decoder.next_out_of_line();
6840            let handles_before = decoder.remaining_handles();
6841            if let Some((inlined, num_bytes, num_handles)) =
6842                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6843            {
6844                let member_inline_size =
6845                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6846                if inlined != (member_inline_size <= 4) {
6847                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6848                }
6849                let inner_offset;
6850                let mut inner_depth = depth.clone();
6851                if inlined {
6852                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6853                    inner_offset = next_offset;
6854                } else {
6855                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6856                    inner_depth.increment()?;
6857                }
6858                let val_ref = self.max_subevents.get_or_insert_with(|| fidl::new_empty!(u8, D));
6859                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
6860                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6861                {
6862                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6863                }
6864                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6865                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6866                }
6867            }
6868
6869            next_offset += envelope_size;
6870            _next_ordinal_to_read += 1;
6871            if next_offset >= end_offset {
6872                return Ok(());
6873            }
6874
6875            // Decode unknown envelopes for gaps in ordinals.
6876            while _next_ordinal_to_read < 4 {
6877                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6878                _next_ordinal_to_read += 1;
6879                next_offset += envelope_size;
6880            }
6881
6882            let next_out_of_line = decoder.next_out_of_line();
6883            let handles_before = decoder.remaining_handles();
6884            if let Some((inlined, num_bytes, num_handles)) =
6885                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6886            {
6887                let member_inline_size =
6888                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6889                if inlined != (member_inline_size <= 4) {
6890                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6891                }
6892                let inner_offset;
6893                let mut inner_depth = depth.clone();
6894                if inlined {
6895                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6896                    inner_offset = next_offset;
6897                } else {
6898                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6899                    inner_depth.increment()?;
6900                }
6901                let val_ref = self.iso_interval.get_or_insert_with(|| fidl::new_empty!(i64, D));
6902                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
6903                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6904                {
6905                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6906                }
6907                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6908                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6909                }
6910            }
6911
6912            next_offset += envelope_size;
6913            _next_ordinal_to_read += 1;
6914            if next_offset >= end_offset {
6915                return Ok(());
6916            }
6917
6918            // Decode unknown envelopes for gaps in ordinals.
6919            while _next_ordinal_to_read < 5 {
6920                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6921                _next_ordinal_to_read += 1;
6922                next_offset += envelope_size;
6923            }
6924
6925            let next_out_of_line = decoder.next_out_of_line();
6926            let handles_before = decoder.remaining_handles();
6927            if let Some((inlined, num_bytes, num_handles)) =
6928                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6929            {
6930                let member_inline_size =
6931                    <CisUnidirectionalParams as fidl::encoding::TypeMarker>::inline_size(
6932                        decoder.context,
6933                    );
6934                if inlined != (member_inline_size <= 4) {
6935                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6936                }
6937                let inner_offset;
6938                let mut inner_depth = depth.clone();
6939                if inlined {
6940                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6941                    inner_offset = next_offset;
6942                } else {
6943                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6944                    inner_depth.increment()?;
6945                }
6946                let val_ref = self
6947                    .central_to_peripheral_params
6948                    .get_or_insert_with(|| fidl::new_empty!(CisUnidirectionalParams, D));
6949                fidl::decode!(
6950                    CisUnidirectionalParams,
6951                    D,
6952                    val_ref,
6953                    decoder,
6954                    inner_offset,
6955                    inner_depth
6956                )?;
6957                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6958                {
6959                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6960                }
6961                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6962                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6963                }
6964            }
6965
6966            next_offset += envelope_size;
6967            _next_ordinal_to_read += 1;
6968            if next_offset >= end_offset {
6969                return Ok(());
6970            }
6971
6972            // Decode unknown envelopes for gaps in ordinals.
6973            while _next_ordinal_to_read < 6 {
6974                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6975                _next_ordinal_to_read += 1;
6976                next_offset += envelope_size;
6977            }
6978
6979            let next_out_of_line = decoder.next_out_of_line();
6980            let handles_before = decoder.remaining_handles();
6981            if let Some((inlined, num_bytes, num_handles)) =
6982                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6983            {
6984                let member_inline_size =
6985                    <CisUnidirectionalParams as fidl::encoding::TypeMarker>::inline_size(
6986                        decoder.context,
6987                    );
6988                if inlined != (member_inline_size <= 4) {
6989                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6990                }
6991                let inner_offset;
6992                let mut inner_depth = depth.clone();
6993                if inlined {
6994                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6995                    inner_offset = next_offset;
6996                } else {
6997                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6998                    inner_depth.increment()?;
6999                }
7000                let val_ref = self
7001                    .peripheral_to_central_params
7002                    .get_or_insert_with(|| fidl::new_empty!(CisUnidirectionalParams, D));
7003                fidl::decode!(
7004                    CisUnidirectionalParams,
7005                    D,
7006                    val_ref,
7007                    decoder,
7008                    inner_offset,
7009                    inner_depth
7010                )?;
7011                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7012                {
7013                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7014                }
7015                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7016                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7017                }
7018            }
7019
7020            next_offset += envelope_size;
7021
7022            // Decode the remaining unknown envelopes.
7023            while next_offset < end_offset {
7024                _next_ordinal_to_read += 1;
7025                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7026                next_offset += envelope_size;
7027            }
7028
7029            Ok(())
7030        }
7031    }
7032
7033    impl CisParameters {
7034        #[inline(always)]
7035        fn max_ordinal_present(&self) -> u64 {
7036            if let Some(_) = self.id {
7037                return 2;
7038            }
7039            if let Some(_) = self.cis_id {
7040                return 1;
7041            }
7042            0
7043        }
7044    }
7045
7046    impl fidl::encoding::ValueTypeMarker for CisParameters {
7047        type Borrowed<'a> = &'a Self;
7048        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7049            value
7050        }
7051    }
7052
7053    unsafe impl fidl::encoding::TypeMarker for CisParameters {
7054        type Owned = Self;
7055
7056        #[inline(always)]
7057        fn inline_align(_context: fidl::encoding::Context) -> usize {
7058            8
7059        }
7060
7061        #[inline(always)]
7062        fn inline_size(_context: fidl::encoding::Context) -> usize {
7063            16
7064        }
7065    }
7066
7067    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CisParameters, D>
7068        for &CisParameters
7069    {
7070        unsafe fn encode(
7071            self,
7072            encoder: &mut fidl::encoding::Encoder<'_, D>,
7073            offset: usize,
7074            mut depth: fidl::encoding::Depth,
7075        ) -> fidl::Result<()> {
7076            encoder.debug_check_bounds::<CisParameters>(offset);
7077            // Vector header
7078            let max_ordinal: u64 = self.max_ordinal_present();
7079            encoder.write_num(max_ordinal, offset);
7080            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7081            // Calling encoder.out_of_line_offset(0) is not allowed.
7082            if max_ordinal == 0 {
7083                return Ok(());
7084            }
7085            depth.increment()?;
7086            let envelope_size = 8;
7087            let bytes_len = max_ordinal as usize * envelope_size;
7088            #[allow(unused_variables)]
7089            let offset = encoder.out_of_line_offset(bytes_len);
7090            let mut _prev_end_offset: usize = 0;
7091            if 1 > max_ordinal {
7092                return Ok(());
7093            }
7094
7095            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7096            // are envelope_size bytes.
7097            let cur_offset: usize = (1 - 1) * envelope_size;
7098
7099            // Zero reserved fields.
7100            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7101
7102            // Safety:
7103            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7104            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7105            //   envelope_size bytes, there is always sufficient room.
7106            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7107                self.cis_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7108                encoder,
7109                offset + cur_offset,
7110                depth,
7111            )?;
7112
7113            _prev_end_offset = cur_offset + envelope_size;
7114            if 2 > max_ordinal {
7115                return Ok(());
7116            }
7117
7118            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7119            // are envelope_size bytes.
7120            let cur_offset: usize = (2 - 1) * envelope_size;
7121
7122            // Zero reserved fields.
7123            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7124
7125            // Safety:
7126            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7127            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7128            //   envelope_size bytes, there is always sufficient room.
7129            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::PeerId, D>(
7130            self.id.as_ref().map(<fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow),
7131            encoder, offset + cur_offset, depth
7132        )?;
7133
7134            _prev_end_offset = cur_offset + envelope_size;
7135
7136            Ok(())
7137        }
7138    }
7139
7140    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CisParameters {
7141        #[inline(always)]
7142        fn new_empty() -> Self {
7143            Self::default()
7144        }
7145
7146        unsafe fn decode(
7147            &mut self,
7148            decoder: &mut fidl::encoding::Decoder<'_, D>,
7149            offset: usize,
7150            mut depth: fidl::encoding::Depth,
7151        ) -> fidl::Result<()> {
7152            decoder.debug_check_bounds::<Self>(offset);
7153            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7154                None => return Err(fidl::Error::NotNullable),
7155                Some(len) => len,
7156            };
7157            // Calling decoder.out_of_line_offset(0) is not allowed.
7158            if len == 0 {
7159                return Ok(());
7160            };
7161            depth.increment()?;
7162            let envelope_size = 8;
7163            let bytes_len = len * envelope_size;
7164            let offset = decoder.out_of_line_offset(bytes_len)?;
7165            // Decode the envelope for each type.
7166            let mut _next_ordinal_to_read = 0;
7167            let mut next_offset = offset;
7168            let end_offset = offset + bytes_len;
7169            _next_ordinal_to_read += 1;
7170            if next_offset >= end_offset {
7171                return Ok(());
7172            }
7173
7174            // Decode unknown envelopes for gaps in ordinals.
7175            while _next_ordinal_to_read < 1 {
7176                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7177                _next_ordinal_to_read += 1;
7178                next_offset += envelope_size;
7179            }
7180
7181            let next_out_of_line = decoder.next_out_of_line();
7182            let handles_before = decoder.remaining_handles();
7183            if let Some((inlined, num_bytes, num_handles)) =
7184                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7185            {
7186                let member_inline_size =
7187                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7188                if inlined != (member_inline_size <= 4) {
7189                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7190                }
7191                let inner_offset;
7192                let mut inner_depth = depth.clone();
7193                if inlined {
7194                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7195                    inner_offset = next_offset;
7196                } else {
7197                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7198                    inner_depth.increment()?;
7199                }
7200                let val_ref = self.cis_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
7201                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7202                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7203                {
7204                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7205                }
7206                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7207                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7208                }
7209            }
7210
7211            next_offset += envelope_size;
7212            _next_ordinal_to_read += 1;
7213            if next_offset >= end_offset {
7214                return Ok(());
7215            }
7216
7217            // Decode unknown envelopes for gaps in ordinals.
7218            while _next_ordinal_to_read < 2 {
7219                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7220                _next_ordinal_to_read += 1;
7221                next_offset += envelope_size;
7222            }
7223
7224            let next_out_of_line = decoder.next_out_of_line();
7225            let handles_before = decoder.remaining_handles();
7226            if let Some((inlined, num_bytes, num_handles)) =
7227                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7228            {
7229                let member_inline_size = <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7230                if inlined != (member_inline_size <= 4) {
7231                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7232                }
7233                let inner_offset;
7234                let mut inner_depth = depth.clone();
7235                if inlined {
7236                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7237                    inner_offset = next_offset;
7238                } else {
7239                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7240                    inner_depth.increment()?;
7241                }
7242                let val_ref = self.id.get_or_insert_with(|| {
7243                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D)
7244                });
7245                fidl::decode!(
7246                    fidl_fuchsia_bluetooth__common::PeerId,
7247                    D,
7248                    val_ref,
7249                    decoder,
7250                    inner_offset,
7251                    inner_depth
7252                )?;
7253                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7254                {
7255                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7256                }
7257                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7258                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7259                }
7260            }
7261
7262            next_offset += envelope_size;
7263
7264            // Decode the remaining unknown envelopes.
7265            while next_offset < end_offset {
7266                _next_ordinal_to_read += 1;
7267                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7268                next_offset += envelope_size;
7269            }
7270
7271            Ok(())
7272        }
7273    }
7274
7275    impl CisUnidirectionalParams {
7276        #[inline(always)]
7277        fn max_ordinal_present(&self) -> u64 {
7278            if let Some(_) = self.flush_timeout {
7279                return 3;
7280            }
7281            if let Some(_) = self.burst_number {
7282                return 2;
7283            }
7284            if let Some(_) = self.transport_latency {
7285                return 1;
7286            }
7287            0
7288        }
7289    }
7290
7291    impl fidl::encoding::ValueTypeMarker for CisUnidirectionalParams {
7292        type Borrowed<'a> = &'a Self;
7293        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7294            value
7295        }
7296    }
7297
7298    unsafe impl fidl::encoding::TypeMarker for CisUnidirectionalParams {
7299        type Owned = Self;
7300
7301        #[inline(always)]
7302        fn inline_align(_context: fidl::encoding::Context) -> usize {
7303            8
7304        }
7305
7306        #[inline(always)]
7307        fn inline_size(_context: fidl::encoding::Context) -> usize {
7308            16
7309        }
7310    }
7311
7312    unsafe impl<D: fidl::encoding::ResourceDialect>
7313        fidl::encoding::Encode<CisUnidirectionalParams, D> for &CisUnidirectionalParams
7314    {
7315        unsafe fn encode(
7316            self,
7317            encoder: &mut fidl::encoding::Encoder<'_, D>,
7318            offset: usize,
7319            mut depth: fidl::encoding::Depth,
7320        ) -> fidl::Result<()> {
7321            encoder.debug_check_bounds::<CisUnidirectionalParams>(offset);
7322            // Vector header
7323            let max_ordinal: u64 = self.max_ordinal_present();
7324            encoder.write_num(max_ordinal, offset);
7325            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7326            // Calling encoder.out_of_line_offset(0) is not allowed.
7327            if max_ordinal == 0 {
7328                return Ok(());
7329            }
7330            depth.increment()?;
7331            let envelope_size = 8;
7332            let bytes_len = max_ordinal as usize * envelope_size;
7333            #[allow(unused_variables)]
7334            let offset = encoder.out_of_line_offset(bytes_len);
7335            let mut _prev_end_offset: usize = 0;
7336            if 1 > max_ordinal {
7337                return Ok(());
7338            }
7339
7340            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7341            // are envelope_size bytes.
7342            let cur_offset: usize = (1 - 1) * envelope_size;
7343
7344            // Zero reserved fields.
7345            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7346
7347            // Safety:
7348            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7349            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7350            //   envelope_size bytes, there is always sufficient room.
7351            fidl::encoding::encode_in_envelope_optional::<i64, D>(
7352                self.transport_latency
7353                    .as_ref()
7354                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
7355                encoder,
7356                offset + cur_offset,
7357                depth,
7358            )?;
7359
7360            _prev_end_offset = cur_offset + envelope_size;
7361            if 2 > max_ordinal {
7362                return Ok(());
7363            }
7364
7365            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7366            // are envelope_size bytes.
7367            let cur_offset: usize = (2 - 1) * envelope_size;
7368
7369            // Zero reserved fields.
7370            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7371
7372            // Safety:
7373            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7374            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7375            //   envelope_size bytes, there is always sufficient room.
7376            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7377                self.burst_number.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7378                encoder,
7379                offset + cur_offset,
7380                depth,
7381            )?;
7382
7383            _prev_end_offset = cur_offset + envelope_size;
7384            if 3 > max_ordinal {
7385                return Ok(());
7386            }
7387
7388            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7389            // are envelope_size bytes.
7390            let cur_offset: usize = (3 - 1) * envelope_size;
7391
7392            // Zero reserved fields.
7393            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7394
7395            // Safety:
7396            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7397            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7398            //   envelope_size bytes, there is always sufficient room.
7399            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7400                self.flush_timeout.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7401                encoder,
7402                offset + cur_offset,
7403                depth,
7404            )?;
7405
7406            _prev_end_offset = cur_offset + envelope_size;
7407
7408            Ok(())
7409        }
7410    }
7411
7412    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7413        for CisUnidirectionalParams
7414    {
7415        #[inline(always)]
7416        fn new_empty() -> Self {
7417            Self::default()
7418        }
7419
7420        unsafe fn decode(
7421            &mut self,
7422            decoder: &mut fidl::encoding::Decoder<'_, D>,
7423            offset: usize,
7424            mut depth: fidl::encoding::Depth,
7425        ) -> fidl::Result<()> {
7426            decoder.debug_check_bounds::<Self>(offset);
7427            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7428                None => return Err(fidl::Error::NotNullable),
7429                Some(len) => len,
7430            };
7431            // Calling decoder.out_of_line_offset(0) is not allowed.
7432            if len == 0 {
7433                return Ok(());
7434            };
7435            depth.increment()?;
7436            let envelope_size = 8;
7437            let bytes_len = len * envelope_size;
7438            let offset = decoder.out_of_line_offset(bytes_len)?;
7439            // Decode the envelope for each type.
7440            let mut _next_ordinal_to_read = 0;
7441            let mut next_offset = offset;
7442            let end_offset = offset + bytes_len;
7443            _next_ordinal_to_read += 1;
7444            if next_offset >= end_offset {
7445                return Ok(());
7446            }
7447
7448            // Decode unknown envelopes for gaps in ordinals.
7449            while _next_ordinal_to_read < 1 {
7450                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7451                _next_ordinal_to_read += 1;
7452                next_offset += envelope_size;
7453            }
7454
7455            let next_out_of_line = decoder.next_out_of_line();
7456            let handles_before = decoder.remaining_handles();
7457            if let Some((inlined, num_bytes, num_handles)) =
7458                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7459            {
7460                let member_inline_size =
7461                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7462                if inlined != (member_inline_size <= 4) {
7463                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7464                }
7465                let inner_offset;
7466                let mut inner_depth = depth.clone();
7467                if inlined {
7468                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7469                    inner_offset = next_offset;
7470                } else {
7471                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7472                    inner_depth.increment()?;
7473                }
7474                let val_ref =
7475                    self.transport_latency.get_or_insert_with(|| fidl::new_empty!(i64, D));
7476                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
7477                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7478                {
7479                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7480                }
7481                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7482                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7483                }
7484            }
7485
7486            next_offset += envelope_size;
7487            _next_ordinal_to_read += 1;
7488            if next_offset >= end_offset {
7489                return Ok(());
7490            }
7491
7492            // Decode unknown envelopes for gaps in ordinals.
7493            while _next_ordinal_to_read < 2 {
7494                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7495                _next_ordinal_to_read += 1;
7496                next_offset += envelope_size;
7497            }
7498
7499            let next_out_of_line = decoder.next_out_of_line();
7500            let handles_before = decoder.remaining_handles();
7501            if let Some((inlined, num_bytes, num_handles)) =
7502                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7503            {
7504                let member_inline_size =
7505                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7506                if inlined != (member_inline_size <= 4) {
7507                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7508                }
7509                let inner_offset;
7510                let mut inner_depth = depth.clone();
7511                if inlined {
7512                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7513                    inner_offset = next_offset;
7514                } else {
7515                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7516                    inner_depth.increment()?;
7517                }
7518                let val_ref = self.burst_number.get_or_insert_with(|| fidl::new_empty!(u8, D));
7519                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7520                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7521                {
7522                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7523                }
7524                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7525                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7526                }
7527            }
7528
7529            next_offset += envelope_size;
7530            _next_ordinal_to_read += 1;
7531            if next_offset >= end_offset {
7532                return Ok(());
7533            }
7534
7535            // Decode unknown envelopes for gaps in ordinals.
7536            while _next_ordinal_to_read < 3 {
7537                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7538                _next_ordinal_to_read += 1;
7539                next_offset += envelope_size;
7540            }
7541
7542            let next_out_of_line = decoder.next_out_of_line();
7543            let handles_before = decoder.remaining_handles();
7544            if let Some((inlined, num_bytes, num_handles)) =
7545                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7546            {
7547                let member_inline_size =
7548                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7549                if inlined != (member_inline_size <= 4) {
7550                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7551                }
7552                let inner_offset;
7553                let mut inner_depth = depth.clone();
7554                if inlined {
7555                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7556                    inner_offset = next_offset;
7557                } else {
7558                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7559                    inner_depth.increment()?;
7560                }
7561                let val_ref = self.flush_timeout.get_or_insert_with(|| fidl::new_empty!(u8, D));
7562                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7563                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7564                {
7565                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7566                }
7567                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7568                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7569                }
7570            }
7571
7572            next_offset += envelope_size;
7573
7574            // Decode the remaining unknown envelopes.
7575            while next_offset < end_offset {
7576                _next_ordinal_to_read += 1;
7577                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7578                next_offset += envelope_size;
7579            }
7580
7581            Ok(())
7582        }
7583    }
7584
7585    impl CodecDelayGetCodecLocalDelayRangeRequest {
7586        #[inline(always)]
7587        fn max_ordinal_present(&self) -> u64 {
7588            if let Some(_) = self.codec_attributes {
7589                return 3;
7590            }
7591            if let Some(_) = self.data_direction {
7592                return 2;
7593            }
7594            if let Some(_) = self.logical_transport_type {
7595                return 1;
7596            }
7597            0
7598        }
7599    }
7600
7601    impl fidl::encoding::ValueTypeMarker for CodecDelayGetCodecLocalDelayRangeRequest {
7602        type Borrowed<'a> = &'a Self;
7603        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7604            value
7605        }
7606    }
7607
7608    unsafe impl fidl::encoding::TypeMarker for CodecDelayGetCodecLocalDelayRangeRequest {
7609        type Owned = Self;
7610
7611        #[inline(always)]
7612        fn inline_align(_context: fidl::encoding::Context) -> usize {
7613            8
7614        }
7615
7616        #[inline(always)]
7617        fn inline_size(_context: fidl::encoding::Context) -> usize {
7618            16
7619        }
7620    }
7621
7622    unsafe impl<D: fidl::encoding::ResourceDialect>
7623        fidl::encoding::Encode<CodecDelayGetCodecLocalDelayRangeRequest, D>
7624        for &CodecDelayGetCodecLocalDelayRangeRequest
7625    {
7626        unsafe fn encode(
7627            self,
7628            encoder: &mut fidl::encoding::Encoder<'_, D>,
7629            offset: usize,
7630            mut depth: fidl::encoding::Depth,
7631        ) -> fidl::Result<()> {
7632            encoder.debug_check_bounds::<CodecDelayGetCodecLocalDelayRangeRequest>(offset);
7633            // Vector header
7634            let max_ordinal: u64 = self.max_ordinal_present();
7635            encoder.write_num(max_ordinal, offset);
7636            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7637            // Calling encoder.out_of_line_offset(0) is not allowed.
7638            if max_ordinal == 0 {
7639                return Ok(());
7640            }
7641            depth.increment()?;
7642            let envelope_size = 8;
7643            let bytes_len = max_ordinal as usize * envelope_size;
7644            #[allow(unused_variables)]
7645            let offset = encoder.out_of_line_offset(bytes_len);
7646            let mut _prev_end_offset: usize = 0;
7647            if 1 > max_ordinal {
7648                return Ok(());
7649            }
7650
7651            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7652            // are envelope_size bytes.
7653            let cur_offset: usize = (1 - 1) * envelope_size;
7654
7655            // Zero reserved fields.
7656            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7657
7658            // Safety:
7659            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7660            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7661            //   envelope_size bytes, there is always sufficient room.
7662            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::LogicalTransportType, D>(
7663            self.logical_transport_type.as_ref().map(<fidl_fuchsia_bluetooth__common::LogicalTransportType as fidl::encoding::ValueTypeMarker>::borrow),
7664            encoder, offset + cur_offset, depth
7665        )?;
7666
7667            _prev_end_offset = cur_offset + envelope_size;
7668            if 2 > max_ordinal {
7669                return Ok(());
7670            }
7671
7672            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7673            // are envelope_size bytes.
7674            let cur_offset: usize = (2 - 1) * envelope_size;
7675
7676            // Zero reserved fields.
7677            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7678
7679            // Safety:
7680            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7681            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7682            //   envelope_size bytes, there is always sufficient room.
7683            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::DataDirection, D>(
7684            self.data_direction.as_ref().map(<fidl_fuchsia_bluetooth__common::DataDirection as fidl::encoding::ValueTypeMarker>::borrow),
7685            encoder, offset + cur_offset, depth
7686        )?;
7687
7688            _prev_end_offset = cur_offset + envelope_size;
7689            if 3 > max_ordinal {
7690                return Ok(());
7691            }
7692
7693            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7694            // are envelope_size bytes.
7695            let cur_offset: usize = (3 - 1) * envelope_size;
7696
7697            // Zero reserved fields.
7698            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7699
7700            // Safety:
7701            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7702            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7703            //   envelope_size bytes, there is always sufficient room.
7704            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::CodecAttributes, D>(
7705            self.codec_attributes.as_ref().map(<fidl_fuchsia_bluetooth__common::CodecAttributes as fidl::encoding::ValueTypeMarker>::borrow),
7706            encoder, offset + cur_offset, depth
7707        )?;
7708
7709            _prev_end_offset = cur_offset + envelope_size;
7710
7711            Ok(())
7712        }
7713    }
7714
7715    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
7716        for CodecDelayGetCodecLocalDelayRangeRequest
7717    {
7718        #[inline(always)]
7719        fn new_empty() -> Self {
7720            Self::default()
7721        }
7722
7723        unsafe fn decode(
7724            &mut self,
7725            decoder: &mut fidl::encoding::Decoder<'_, D>,
7726            offset: usize,
7727            mut depth: fidl::encoding::Depth,
7728        ) -> fidl::Result<()> {
7729            decoder.debug_check_bounds::<Self>(offset);
7730            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7731                None => return Err(fidl::Error::NotNullable),
7732                Some(len) => len,
7733            };
7734            // Calling decoder.out_of_line_offset(0) is not allowed.
7735            if len == 0 {
7736                return Ok(());
7737            };
7738            depth.increment()?;
7739            let envelope_size = 8;
7740            let bytes_len = len * envelope_size;
7741            let offset = decoder.out_of_line_offset(bytes_len)?;
7742            // Decode the envelope for each type.
7743            let mut _next_ordinal_to_read = 0;
7744            let mut next_offset = offset;
7745            let end_offset = offset + bytes_len;
7746            _next_ordinal_to_read += 1;
7747            if next_offset >= end_offset {
7748                return Ok(());
7749            }
7750
7751            // Decode unknown envelopes for gaps in ordinals.
7752            while _next_ordinal_to_read < 1 {
7753                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7754                _next_ordinal_to_read += 1;
7755                next_offset += envelope_size;
7756            }
7757
7758            let next_out_of_line = decoder.next_out_of_line();
7759            let handles_before = decoder.remaining_handles();
7760            if let Some((inlined, num_bytes, num_handles)) =
7761                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7762            {
7763                let member_inline_size = <fidl_fuchsia_bluetooth__common::LogicalTransportType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7764                if inlined != (member_inline_size <= 4) {
7765                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7766                }
7767                let inner_offset;
7768                let mut inner_depth = depth.clone();
7769                if inlined {
7770                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7771                    inner_offset = next_offset;
7772                } else {
7773                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7774                    inner_depth.increment()?;
7775                }
7776                let val_ref = self.logical_transport_type.get_or_insert_with(|| {
7777                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::LogicalTransportType, D)
7778                });
7779                fidl::decode!(
7780                    fidl_fuchsia_bluetooth__common::LogicalTransportType,
7781                    D,
7782                    val_ref,
7783                    decoder,
7784                    inner_offset,
7785                    inner_depth
7786                )?;
7787                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7788                {
7789                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7790                }
7791                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7792                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7793                }
7794            }
7795
7796            next_offset += envelope_size;
7797            _next_ordinal_to_read += 1;
7798            if next_offset >= end_offset {
7799                return Ok(());
7800            }
7801
7802            // Decode unknown envelopes for gaps in ordinals.
7803            while _next_ordinal_to_read < 2 {
7804                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7805                _next_ordinal_to_read += 1;
7806                next_offset += envelope_size;
7807            }
7808
7809            let next_out_of_line = decoder.next_out_of_line();
7810            let handles_before = decoder.remaining_handles();
7811            if let Some((inlined, num_bytes, num_handles)) =
7812                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7813            {
7814                let member_inline_size = <fidl_fuchsia_bluetooth__common::DataDirection as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7815                if inlined != (member_inline_size <= 4) {
7816                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7817                }
7818                let inner_offset;
7819                let mut inner_depth = depth.clone();
7820                if inlined {
7821                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7822                    inner_offset = next_offset;
7823                } else {
7824                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7825                    inner_depth.increment()?;
7826                }
7827                let val_ref = self.data_direction.get_or_insert_with(|| {
7828                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::DataDirection, D)
7829                });
7830                fidl::decode!(
7831                    fidl_fuchsia_bluetooth__common::DataDirection,
7832                    D,
7833                    val_ref,
7834                    decoder,
7835                    inner_offset,
7836                    inner_depth
7837                )?;
7838                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7839                {
7840                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7841                }
7842                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7843                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7844                }
7845            }
7846
7847            next_offset += envelope_size;
7848            _next_ordinal_to_read += 1;
7849            if next_offset >= end_offset {
7850                return Ok(());
7851            }
7852
7853            // Decode unknown envelopes for gaps in ordinals.
7854            while _next_ordinal_to_read < 3 {
7855                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7856                _next_ordinal_to_read += 1;
7857                next_offset += envelope_size;
7858            }
7859
7860            let next_out_of_line = decoder.next_out_of_line();
7861            let handles_before = decoder.remaining_handles();
7862            if let Some((inlined, num_bytes, num_handles)) =
7863                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7864            {
7865                let member_inline_size = <fidl_fuchsia_bluetooth__common::CodecAttributes as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7866                if inlined != (member_inline_size <= 4) {
7867                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7868                }
7869                let inner_offset;
7870                let mut inner_depth = depth.clone();
7871                if inlined {
7872                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7873                    inner_offset = next_offset;
7874                } else {
7875                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7876                    inner_depth.increment()?;
7877                }
7878                let val_ref = self.codec_attributes.get_or_insert_with(|| {
7879                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::CodecAttributes, D)
7880                });
7881                fidl::decode!(
7882                    fidl_fuchsia_bluetooth__common::CodecAttributes,
7883                    D,
7884                    val_ref,
7885                    decoder,
7886                    inner_offset,
7887                    inner_depth
7888                )?;
7889                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7890                {
7891                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7892                }
7893                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7894                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7895                }
7896            }
7897
7898            next_offset += envelope_size;
7899
7900            // Decode the remaining unknown envelopes.
7901            while next_offset < end_offset {
7902                _next_ordinal_to_read += 1;
7903                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7904                next_offset += envelope_size;
7905            }
7906
7907            Ok(())
7908        }
7909    }
7910
7911    impl CodecDelayGetCodecLocalDelayRangeResponse {
7912        #[inline(always)]
7913        fn max_ordinal_present(&self) -> u64 {
7914            if let Some(_) = self.max_controller_delay {
7915                return 2;
7916            }
7917            if let Some(_) = self.min_controller_delay {
7918                return 1;
7919            }
7920            0
7921        }
7922    }
7923
7924    impl fidl::encoding::ValueTypeMarker for CodecDelayGetCodecLocalDelayRangeResponse {
7925        type Borrowed<'a> = &'a Self;
7926        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7927            value
7928        }
7929    }
7930
7931    unsafe impl fidl::encoding::TypeMarker for CodecDelayGetCodecLocalDelayRangeResponse {
7932        type Owned = Self;
7933
7934        #[inline(always)]
7935        fn inline_align(_context: fidl::encoding::Context) -> usize {
7936            8
7937        }
7938
7939        #[inline(always)]
7940        fn inline_size(_context: fidl::encoding::Context) -> usize {
7941            16
7942        }
7943    }
7944
7945    unsafe impl<D: fidl::encoding::ResourceDialect>
7946        fidl::encoding::Encode<CodecDelayGetCodecLocalDelayRangeResponse, D>
7947        for &CodecDelayGetCodecLocalDelayRangeResponse
7948    {
7949        unsafe fn encode(
7950            self,
7951            encoder: &mut fidl::encoding::Encoder<'_, D>,
7952            offset: usize,
7953            mut depth: fidl::encoding::Depth,
7954        ) -> fidl::Result<()> {
7955            encoder.debug_check_bounds::<CodecDelayGetCodecLocalDelayRangeResponse>(offset);
7956            // Vector header
7957            let max_ordinal: u64 = self.max_ordinal_present();
7958            encoder.write_num(max_ordinal, offset);
7959            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7960            // Calling encoder.out_of_line_offset(0) is not allowed.
7961            if max_ordinal == 0 {
7962                return Ok(());
7963            }
7964            depth.increment()?;
7965            let envelope_size = 8;
7966            let bytes_len = max_ordinal as usize * envelope_size;
7967            #[allow(unused_variables)]
7968            let offset = encoder.out_of_line_offset(bytes_len);
7969            let mut _prev_end_offset: usize = 0;
7970            if 1 > max_ordinal {
7971                return Ok(());
7972            }
7973
7974            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7975            // are envelope_size bytes.
7976            let cur_offset: usize = (1 - 1) * envelope_size;
7977
7978            // Zero reserved fields.
7979            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7980
7981            // Safety:
7982            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7983            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7984            //   envelope_size bytes, there is always sufficient room.
7985            fidl::encoding::encode_in_envelope_optional::<i64, D>(
7986                self.min_controller_delay
7987                    .as_ref()
7988                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
7989                encoder,
7990                offset + cur_offset,
7991                depth,
7992            )?;
7993
7994            _prev_end_offset = cur_offset + envelope_size;
7995            if 2 > max_ordinal {
7996                return Ok(());
7997            }
7998
7999            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8000            // are envelope_size bytes.
8001            let cur_offset: usize = (2 - 1) * envelope_size;
8002
8003            // Zero reserved fields.
8004            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8005
8006            // Safety:
8007            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8008            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8009            //   envelope_size bytes, there is always sufficient room.
8010            fidl::encoding::encode_in_envelope_optional::<i64, D>(
8011                self.max_controller_delay
8012                    .as_ref()
8013                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
8014                encoder,
8015                offset + cur_offset,
8016                depth,
8017            )?;
8018
8019            _prev_end_offset = cur_offset + envelope_size;
8020
8021            Ok(())
8022        }
8023    }
8024
8025    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8026        for CodecDelayGetCodecLocalDelayRangeResponse
8027    {
8028        #[inline(always)]
8029        fn new_empty() -> Self {
8030            Self::default()
8031        }
8032
8033        unsafe fn decode(
8034            &mut self,
8035            decoder: &mut fidl::encoding::Decoder<'_, D>,
8036            offset: usize,
8037            mut depth: fidl::encoding::Depth,
8038        ) -> fidl::Result<()> {
8039            decoder.debug_check_bounds::<Self>(offset);
8040            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8041                None => return Err(fidl::Error::NotNullable),
8042                Some(len) => len,
8043            };
8044            // Calling decoder.out_of_line_offset(0) is not allowed.
8045            if len == 0 {
8046                return Ok(());
8047            };
8048            depth.increment()?;
8049            let envelope_size = 8;
8050            let bytes_len = len * envelope_size;
8051            let offset = decoder.out_of_line_offset(bytes_len)?;
8052            // Decode the envelope for each type.
8053            let mut _next_ordinal_to_read = 0;
8054            let mut next_offset = offset;
8055            let end_offset = offset + bytes_len;
8056            _next_ordinal_to_read += 1;
8057            if next_offset >= end_offset {
8058                return Ok(());
8059            }
8060
8061            // Decode unknown envelopes for gaps in ordinals.
8062            while _next_ordinal_to_read < 1 {
8063                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8064                _next_ordinal_to_read += 1;
8065                next_offset += envelope_size;
8066            }
8067
8068            let next_out_of_line = decoder.next_out_of_line();
8069            let handles_before = decoder.remaining_handles();
8070            if let Some((inlined, num_bytes, num_handles)) =
8071                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8072            {
8073                let member_inline_size =
8074                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8075                if inlined != (member_inline_size <= 4) {
8076                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8077                }
8078                let inner_offset;
8079                let mut inner_depth = depth.clone();
8080                if inlined {
8081                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8082                    inner_offset = next_offset;
8083                } else {
8084                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8085                    inner_depth.increment()?;
8086                }
8087                let val_ref =
8088                    self.min_controller_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
8089                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
8090                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8091                {
8092                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8093                }
8094                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8095                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8096                }
8097            }
8098
8099            next_offset += envelope_size;
8100            _next_ordinal_to_read += 1;
8101            if next_offset >= end_offset {
8102                return Ok(());
8103            }
8104
8105            // Decode unknown envelopes for gaps in ordinals.
8106            while _next_ordinal_to_read < 2 {
8107                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8108                _next_ordinal_to_read += 1;
8109                next_offset += envelope_size;
8110            }
8111
8112            let next_out_of_line = decoder.next_out_of_line();
8113            let handles_before = decoder.remaining_handles();
8114            if let Some((inlined, num_bytes, num_handles)) =
8115                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8116            {
8117                let member_inline_size =
8118                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8119                if inlined != (member_inline_size <= 4) {
8120                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8121                }
8122                let inner_offset;
8123                let mut inner_depth = depth.clone();
8124                if inlined {
8125                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8126                    inner_offset = next_offset;
8127                } else {
8128                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8129                    inner_depth.increment()?;
8130                }
8131                let val_ref =
8132                    self.max_controller_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
8133                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
8134                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8135                {
8136                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8137                }
8138                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8139                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8140                }
8141            }
8142
8143            next_offset += envelope_size;
8144
8145            // Decode the remaining unknown envelopes.
8146            while next_offset < end_offset {
8147                _next_ordinal_to_read += 1;
8148                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8149                next_offset += envelope_size;
8150            }
8151
8152            Ok(())
8153        }
8154    }
8155
8156    impl ConnectedIsochronousGroupEstablishStreamsRequest {
8157        #[inline(always)]
8158        fn max_ordinal_present(&self) -> u64 {
8159            if let Some(_) = self.cis_params {
8160                return 1;
8161            }
8162            0
8163        }
8164    }
8165
8166    impl fidl::encoding::ValueTypeMarker for ConnectedIsochronousGroupEstablishStreamsRequest {
8167        type Borrowed<'a> = &'a Self;
8168        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8169            value
8170        }
8171    }
8172
8173    unsafe impl fidl::encoding::TypeMarker for ConnectedIsochronousGroupEstablishStreamsRequest {
8174        type Owned = Self;
8175
8176        #[inline(always)]
8177        fn inline_align(_context: fidl::encoding::Context) -> usize {
8178            8
8179        }
8180
8181        #[inline(always)]
8182        fn inline_size(_context: fidl::encoding::Context) -> usize {
8183            16
8184        }
8185    }
8186
8187    unsafe impl<D: fidl::encoding::ResourceDialect>
8188        fidl::encoding::Encode<ConnectedIsochronousGroupEstablishStreamsRequest, D>
8189        for &ConnectedIsochronousGroupEstablishStreamsRequest
8190    {
8191        unsafe fn encode(
8192            self,
8193            encoder: &mut fidl::encoding::Encoder<'_, D>,
8194            offset: usize,
8195            mut depth: fidl::encoding::Depth,
8196        ) -> fidl::Result<()> {
8197            encoder.debug_check_bounds::<ConnectedIsochronousGroupEstablishStreamsRequest>(offset);
8198            // Vector header
8199            let max_ordinal: u64 = self.max_ordinal_present();
8200            encoder.write_num(max_ordinal, offset);
8201            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8202            // Calling encoder.out_of_line_offset(0) is not allowed.
8203            if max_ordinal == 0 {
8204                return Ok(());
8205            }
8206            depth.increment()?;
8207            let envelope_size = 8;
8208            let bytes_len = max_ordinal as usize * envelope_size;
8209            #[allow(unused_variables)]
8210            let offset = encoder.out_of_line_offset(bytes_len);
8211            let mut _prev_end_offset: usize = 0;
8212            if 1 > max_ordinal {
8213                return Ok(());
8214            }
8215
8216            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8217            // are envelope_size bytes.
8218            let cur_offset: usize = (1 - 1) * envelope_size;
8219
8220            // Zero reserved fields.
8221            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8222
8223            // Safety:
8224            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8225            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8226            //   envelope_size bytes, there is always sufficient room.
8227            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<CisParameters, 31>, D>(
8228            self.cis_params.as_ref().map(<fidl::encoding::Vector<CisParameters, 31> as fidl::encoding::ValueTypeMarker>::borrow),
8229            encoder, offset + cur_offset, depth
8230        )?;
8231
8232            _prev_end_offset = cur_offset + envelope_size;
8233
8234            Ok(())
8235        }
8236    }
8237
8238    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
8239        for ConnectedIsochronousGroupEstablishStreamsRequest
8240    {
8241        #[inline(always)]
8242        fn new_empty() -> Self {
8243            Self::default()
8244        }
8245
8246        unsafe fn decode(
8247            &mut self,
8248            decoder: &mut fidl::encoding::Decoder<'_, D>,
8249            offset: usize,
8250            mut depth: fidl::encoding::Depth,
8251        ) -> fidl::Result<()> {
8252            decoder.debug_check_bounds::<Self>(offset);
8253            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8254                None => return Err(fidl::Error::NotNullable),
8255                Some(len) => len,
8256            };
8257            // Calling decoder.out_of_line_offset(0) is not allowed.
8258            if len == 0 {
8259                return Ok(());
8260            };
8261            depth.increment()?;
8262            let envelope_size = 8;
8263            let bytes_len = len * envelope_size;
8264            let offset = decoder.out_of_line_offset(bytes_len)?;
8265            // Decode the envelope for each type.
8266            let mut _next_ordinal_to_read = 0;
8267            let mut next_offset = offset;
8268            let end_offset = offset + bytes_len;
8269            _next_ordinal_to_read += 1;
8270            if next_offset >= end_offset {
8271                return Ok(());
8272            }
8273
8274            // Decode unknown envelopes for gaps in ordinals.
8275            while _next_ordinal_to_read < 1 {
8276                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8277                _next_ordinal_to_read += 1;
8278                next_offset += envelope_size;
8279            }
8280
8281            let next_out_of_line = decoder.next_out_of_line();
8282            let handles_before = decoder.remaining_handles();
8283            if let Some((inlined, num_bytes, num_handles)) =
8284                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8285            {
8286                let member_inline_size = <fidl::encoding::Vector<CisParameters, 31> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8287                if inlined != (member_inline_size <= 4) {
8288                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8289                }
8290                let inner_offset;
8291                let mut inner_depth = depth.clone();
8292                if inlined {
8293                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8294                    inner_offset = next_offset;
8295                } else {
8296                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8297                    inner_depth.increment()?;
8298                }
8299                let val_ref = self.cis_params.get_or_insert_with(
8300                    || fidl::new_empty!(fidl::encoding::Vector<CisParameters, 31>, D),
8301                );
8302                fidl::decode!(fidl::encoding::Vector<CisParameters, 31>, D, val_ref, decoder, inner_offset, inner_depth)?;
8303                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8304                {
8305                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8306                }
8307                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8308                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8309                }
8310            }
8311
8312            next_offset += envelope_size;
8313
8314            // Decode the remaining unknown envelopes.
8315            while next_offset < end_offset {
8316                _next_ordinal_to_read += 1;
8317                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8318                next_offset += envelope_size;
8319            }
8320
8321            Ok(())
8322        }
8323    }
8324
8325    impl ConnectionOptions {
8326        #[inline(always)]
8327        fn max_ordinal_present(&self) -> u64 {
8328            if let Some(_) = self.service_filter {
8329                return 2;
8330            }
8331            if let Some(_) = self.bondable_mode {
8332                return 1;
8333            }
8334            0
8335        }
8336    }
8337
8338    impl fidl::encoding::ValueTypeMarker for ConnectionOptions {
8339        type Borrowed<'a> = &'a Self;
8340        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8341            value
8342        }
8343    }
8344
8345    unsafe impl fidl::encoding::TypeMarker for ConnectionOptions {
8346        type Owned = Self;
8347
8348        #[inline(always)]
8349        fn inline_align(_context: fidl::encoding::Context) -> usize {
8350            8
8351        }
8352
8353        #[inline(always)]
8354        fn inline_size(_context: fidl::encoding::Context) -> usize {
8355            16
8356        }
8357    }
8358
8359    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ConnectionOptions, D>
8360        for &ConnectionOptions
8361    {
8362        unsafe fn encode(
8363            self,
8364            encoder: &mut fidl::encoding::Encoder<'_, D>,
8365            offset: usize,
8366            mut depth: fidl::encoding::Depth,
8367        ) -> fidl::Result<()> {
8368            encoder.debug_check_bounds::<ConnectionOptions>(offset);
8369            // Vector header
8370            let max_ordinal: u64 = self.max_ordinal_present();
8371            encoder.write_num(max_ordinal, offset);
8372            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8373            // Calling encoder.out_of_line_offset(0) is not allowed.
8374            if max_ordinal == 0 {
8375                return Ok(());
8376            }
8377            depth.increment()?;
8378            let envelope_size = 8;
8379            let bytes_len = max_ordinal as usize * envelope_size;
8380            #[allow(unused_variables)]
8381            let offset = encoder.out_of_line_offset(bytes_len);
8382            let mut _prev_end_offset: usize = 0;
8383            if 1 > max_ordinal {
8384                return Ok(());
8385            }
8386
8387            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8388            // are envelope_size bytes.
8389            let cur_offset: usize = (1 - 1) * envelope_size;
8390
8391            // Zero reserved fields.
8392            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8393
8394            // Safety:
8395            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8396            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8397            //   envelope_size bytes, there is always sufficient room.
8398            fidl::encoding::encode_in_envelope_optional::<bool, D>(
8399                self.bondable_mode.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
8400                encoder,
8401                offset + cur_offset,
8402                depth,
8403            )?;
8404
8405            _prev_end_offset = cur_offset + envelope_size;
8406            if 2 > max_ordinal {
8407                return Ok(());
8408            }
8409
8410            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8411            // are envelope_size bytes.
8412            let cur_offset: usize = (2 - 1) * envelope_size;
8413
8414            // Zero reserved fields.
8415            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8416
8417            // Safety:
8418            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8419            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8420            //   envelope_size bytes, there is always sufficient room.
8421            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Uuid, D>(
8422            self.service_filter.as_ref().map(<fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow),
8423            encoder, offset + cur_offset, depth
8424        )?;
8425
8426            _prev_end_offset = cur_offset + envelope_size;
8427
8428            Ok(())
8429        }
8430    }
8431
8432    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectionOptions {
8433        #[inline(always)]
8434        fn new_empty() -> Self {
8435            Self::default()
8436        }
8437
8438        unsafe fn decode(
8439            &mut self,
8440            decoder: &mut fidl::encoding::Decoder<'_, D>,
8441            offset: usize,
8442            mut depth: fidl::encoding::Depth,
8443        ) -> fidl::Result<()> {
8444            decoder.debug_check_bounds::<Self>(offset);
8445            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8446                None => return Err(fidl::Error::NotNullable),
8447                Some(len) => len,
8448            };
8449            // Calling decoder.out_of_line_offset(0) is not allowed.
8450            if len == 0 {
8451                return Ok(());
8452            };
8453            depth.increment()?;
8454            let envelope_size = 8;
8455            let bytes_len = len * envelope_size;
8456            let offset = decoder.out_of_line_offset(bytes_len)?;
8457            // Decode the envelope for each type.
8458            let mut _next_ordinal_to_read = 0;
8459            let mut next_offset = offset;
8460            let end_offset = offset + bytes_len;
8461            _next_ordinal_to_read += 1;
8462            if next_offset >= end_offset {
8463                return Ok(());
8464            }
8465
8466            // Decode unknown envelopes for gaps in ordinals.
8467            while _next_ordinal_to_read < 1 {
8468                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8469                _next_ordinal_to_read += 1;
8470                next_offset += envelope_size;
8471            }
8472
8473            let next_out_of_line = decoder.next_out_of_line();
8474            let handles_before = decoder.remaining_handles();
8475            if let Some((inlined, num_bytes, num_handles)) =
8476                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8477            {
8478                let member_inline_size =
8479                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8480                if inlined != (member_inline_size <= 4) {
8481                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8482                }
8483                let inner_offset;
8484                let mut inner_depth = depth.clone();
8485                if inlined {
8486                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8487                    inner_offset = next_offset;
8488                } else {
8489                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8490                    inner_depth.increment()?;
8491                }
8492                let val_ref = self.bondable_mode.get_or_insert_with(|| fidl::new_empty!(bool, D));
8493                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
8494                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8495                {
8496                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8497                }
8498                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8499                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8500                }
8501            }
8502
8503            next_offset += envelope_size;
8504            _next_ordinal_to_read += 1;
8505            if next_offset >= end_offset {
8506                return Ok(());
8507            }
8508
8509            // Decode unknown envelopes for gaps in ordinals.
8510            while _next_ordinal_to_read < 2 {
8511                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8512                _next_ordinal_to_read += 1;
8513                next_offset += envelope_size;
8514            }
8515
8516            let next_out_of_line = decoder.next_out_of_line();
8517            let handles_before = decoder.remaining_handles();
8518            if let Some((inlined, num_bytes, num_handles)) =
8519                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8520            {
8521                let member_inline_size = <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8522                if inlined != (member_inline_size <= 4) {
8523                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8524                }
8525                let inner_offset;
8526                let mut inner_depth = depth.clone();
8527                if inlined {
8528                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8529                    inner_offset = next_offset;
8530                } else {
8531                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8532                    inner_depth.increment()?;
8533                }
8534                let val_ref = self.service_filter.get_or_insert_with(|| {
8535                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D)
8536                });
8537                fidl::decode!(
8538                    fidl_fuchsia_bluetooth__common::Uuid,
8539                    D,
8540                    val_ref,
8541                    decoder,
8542                    inner_offset,
8543                    inner_depth
8544                )?;
8545                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8546                {
8547                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8548                }
8549                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8550                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8551                }
8552            }
8553
8554            next_offset += envelope_size;
8555
8556            // Decode the remaining unknown envelopes.
8557            while next_offset < end_offset {
8558                _next_ordinal_to_read += 1;
8559                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8560                next_offset += envelope_size;
8561            }
8562
8563            Ok(())
8564        }
8565    }
8566
8567    impl Extended {
8568        #[inline(always)]
8569        fn max_ordinal_present(&self) -> u64 {
8570            0
8571        }
8572    }
8573
8574    impl fidl::encoding::ValueTypeMarker for Extended {
8575        type Borrowed<'a> = &'a Self;
8576        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8577            value
8578        }
8579    }
8580
8581    unsafe impl fidl::encoding::TypeMarker for Extended {
8582        type Owned = Self;
8583
8584        #[inline(always)]
8585        fn inline_align(_context: fidl::encoding::Context) -> usize {
8586            8
8587        }
8588
8589        #[inline(always)]
8590        fn inline_size(_context: fidl::encoding::Context) -> usize {
8591            16
8592        }
8593    }
8594
8595    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Extended, D> for &Extended {
8596        unsafe fn encode(
8597            self,
8598            encoder: &mut fidl::encoding::Encoder<'_, D>,
8599            offset: usize,
8600            mut depth: fidl::encoding::Depth,
8601        ) -> fidl::Result<()> {
8602            encoder.debug_check_bounds::<Extended>(offset);
8603            // Vector header
8604            let max_ordinal: u64 = self.max_ordinal_present();
8605            encoder.write_num(max_ordinal, offset);
8606            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8607            // Calling encoder.out_of_line_offset(0) is not allowed.
8608            if max_ordinal == 0 {
8609                return Ok(());
8610            }
8611            depth.increment()?;
8612            let envelope_size = 8;
8613            let bytes_len = max_ordinal as usize * envelope_size;
8614            #[allow(unused_variables)]
8615            let offset = encoder.out_of_line_offset(bytes_len);
8616            let mut _prev_end_offset: usize = 0;
8617
8618            Ok(())
8619        }
8620    }
8621
8622    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Extended {
8623        #[inline(always)]
8624        fn new_empty() -> Self {
8625            Self::default()
8626        }
8627
8628        unsafe fn decode(
8629            &mut self,
8630            decoder: &mut fidl::encoding::Decoder<'_, D>,
8631            offset: usize,
8632            mut depth: fidl::encoding::Depth,
8633        ) -> fidl::Result<()> {
8634            decoder.debug_check_bounds::<Self>(offset);
8635            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8636                None => return Err(fidl::Error::NotNullable),
8637                Some(len) => len,
8638            };
8639            // Calling decoder.out_of_line_offset(0) is not allowed.
8640            if len == 0 {
8641                return Ok(());
8642            };
8643            depth.increment()?;
8644            let envelope_size = 8;
8645            let bytes_len = len * envelope_size;
8646            let offset = decoder.out_of_line_offset(bytes_len)?;
8647            // Decode the envelope for each type.
8648            let mut _next_ordinal_to_read = 0;
8649            let mut next_offset = offset;
8650            let end_offset = offset + bytes_len;
8651
8652            // Decode the remaining unknown envelopes.
8653            while next_offset < end_offset {
8654                _next_ordinal_to_read += 1;
8655                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8656                next_offset += envelope_size;
8657            }
8658
8659            Ok(())
8660        }
8661    }
8662
8663    impl Filter {
8664        #[inline(always)]
8665        fn max_ordinal_present(&self) -> u64 {
8666            if let Some(_) = self.solicitation_uuid {
8667                return 7;
8668            }
8669            if let Some(_) = self.max_path_loss {
8670                return 6;
8671            }
8672            if let Some(_) = self.name {
8673                return 5;
8674            }
8675            if let Some(_) = self.connectable {
8676                return 4;
8677            }
8678            if let Some(_) = self.manufacturer_id {
8679                return 3;
8680            }
8681            if let Some(_) = self.service_data_uuid {
8682                return 2;
8683            }
8684            if let Some(_) = self.service_uuid {
8685                return 1;
8686            }
8687            0
8688        }
8689    }
8690
8691    impl fidl::encoding::ValueTypeMarker for Filter {
8692        type Borrowed<'a> = &'a Self;
8693        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8694            value
8695        }
8696    }
8697
8698    unsafe impl fidl::encoding::TypeMarker for Filter {
8699        type Owned = Self;
8700
8701        #[inline(always)]
8702        fn inline_align(_context: fidl::encoding::Context) -> usize {
8703            8
8704        }
8705
8706        #[inline(always)]
8707        fn inline_size(_context: fidl::encoding::Context) -> usize {
8708            16
8709        }
8710    }
8711
8712    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Filter, D> for &Filter {
8713        unsafe fn encode(
8714            self,
8715            encoder: &mut fidl::encoding::Encoder<'_, D>,
8716            offset: usize,
8717            mut depth: fidl::encoding::Depth,
8718        ) -> fidl::Result<()> {
8719            encoder.debug_check_bounds::<Filter>(offset);
8720            // Vector header
8721            let max_ordinal: u64 = self.max_ordinal_present();
8722            encoder.write_num(max_ordinal, offset);
8723            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8724            // Calling encoder.out_of_line_offset(0) is not allowed.
8725            if max_ordinal == 0 {
8726                return Ok(());
8727            }
8728            depth.increment()?;
8729            let envelope_size = 8;
8730            let bytes_len = max_ordinal as usize * envelope_size;
8731            #[allow(unused_variables)]
8732            let offset = encoder.out_of_line_offset(bytes_len);
8733            let mut _prev_end_offset: usize = 0;
8734            if 1 > max_ordinal {
8735                return Ok(());
8736            }
8737
8738            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8739            // are envelope_size bytes.
8740            let cur_offset: usize = (1 - 1) * envelope_size;
8741
8742            // Zero reserved fields.
8743            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8744
8745            // Safety:
8746            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8747            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8748            //   envelope_size bytes, there is always sufficient room.
8749            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Uuid, D>(
8750            self.service_uuid.as_ref().map(<fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow),
8751            encoder, offset + cur_offset, depth
8752        )?;
8753
8754            _prev_end_offset = cur_offset + envelope_size;
8755            if 2 > max_ordinal {
8756                return Ok(());
8757            }
8758
8759            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8760            // are envelope_size bytes.
8761            let cur_offset: usize = (2 - 1) * envelope_size;
8762
8763            // Zero reserved fields.
8764            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8765
8766            // Safety:
8767            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8768            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8769            //   envelope_size bytes, there is always sufficient room.
8770            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Uuid, D>(
8771            self.service_data_uuid.as_ref().map(<fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow),
8772            encoder, offset + cur_offset, depth
8773        )?;
8774
8775            _prev_end_offset = cur_offset + envelope_size;
8776            if 3 > max_ordinal {
8777                return Ok(());
8778            }
8779
8780            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8781            // are envelope_size bytes.
8782            let cur_offset: usize = (3 - 1) * envelope_size;
8783
8784            // Zero reserved fields.
8785            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8786
8787            // Safety:
8788            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8789            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8790            //   envelope_size bytes, there is always sufficient room.
8791            fidl::encoding::encode_in_envelope_optional::<u16, D>(
8792                self.manufacturer_id.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
8793                encoder,
8794                offset + cur_offset,
8795                depth,
8796            )?;
8797
8798            _prev_end_offset = cur_offset + envelope_size;
8799            if 4 > max_ordinal {
8800                return Ok(());
8801            }
8802
8803            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8804            // are envelope_size bytes.
8805            let cur_offset: usize = (4 - 1) * envelope_size;
8806
8807            // Zero reserved fields.
8808            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8809
8810            // Safety:
8811            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8812            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8813            //   envelope_size bytes, there is always sufficient room.
8814            fidl::encoding::encode_in_envelope_optional::<bool, D>(
8815                self.connectable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
8816                encoder,
8817                offset + cur_offset,
8818                depth,
8819            )?;
8820
8821            _prev_end_offset = cur_offset + envelope_size;
8822            if 5 > max_ordinal {
8823                return Ok(());
8824            }
8825
8826            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8827            // are envelope_size bytes.
8828            let cur_offset: usize = (5 - 1) * envelope_size;
8829
8830            // Zero reserved fields.
8831            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8832
8833            // Safety:
8834            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8835            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8836            //   envelope_size bytes, there is always sufficient room.
8837            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<248>, D>(
8838                self.name.as_ref().map(
8839                    <fidl::encoding::BoundedString<248> as fidl::encoding::ValueTypeMarker>::borrow,
8840                ),
8841                encoder,
8842                offset + cur_offset,
8843                depth,
8844            )?;
8845
8846            _prev_end_offset = cur_offset + envelope_size;
8847            if 6 > 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 = (6 - 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::<i8, D>(
8863                self.max_path_loss.as_ref().map(<i8 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 7 > 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 = (7 - 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::<fidl_fuchsia_bluetooth__common::Uuid, D>(
8886            self.solicitation_uuid.as_ref().map(<fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::ValueTypeMarker>::borrow),
8887            encoder, offset + cur_offset, depth
8888        )?;
8889
8890            _prev_end_offset = cur_offset + envelope_size;
8891
8892            Ok(())
8893        }
8894    }
8895
8896    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Filter {
8897        #[inline(always)]
8898        fn new_empty() -> Self {
8899            Self::default()
8900        }
8901
8902        unsafe fn decode(
8903            &mut self,
8904            decoder: &mut fidl::encoding::Decoder<'_, D>,
8905            offset: usize,
8906            mut depth: fidl::encoding::Depth,
8907        ) -> fidl::Result<()> {
8908            decoder.debug_check_bounds::<Self>(offset);
8909            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8910                None => return Err(fidl::Error::NotNullable),
8911                Some(len) => len,
8912            };
8913            // Calling decoder.out_of_line_offset(0) is not allowed.
8914            if len == 0 {
8915                return Ok(());
8916            };
8917            depth.increment()?;
8918            let envelope_size = 8;
8919            let bytes_len = len * envelope_size;
8920            let offset = decoder.out_of_line_offset(bytes_len)?;
8921            // Decode the envelope for each type.
8922            let mut _next_ordinal_to_read = 0;
8923            let mut next_offset = offset;
8924            let end_offset = offset + bytes_len;
8925            _next_ordinal_to_read += 1;
8926            if next_offset >= end_offset {
8927                return Ok(());
8928            }
8929
8930            // Decode unknown envelopes for gaps in ordinals.
8931            while _next_ordinal_to_read < 1 {
8932                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8933                _next_ordinal_to_read += 1;
8934                next_offset += envelope_size;
8935            }
8936
8937            let next_out_of_line = decoder.next_out_of_line();
8938            let handles_before = decoder.remaining_handles();
8939            if let Some((inlined, num_bytes, num_handles)) =
8940                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8941            {
8942                let member_inline_size = <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8943                if inlined != (member_inline_size <= 4) {
8944                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8945                }
8946                let inner_offset;
8947                let mut inner_depth = depth.clone();
8948                if inlined {
8949                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8950                    inner_offset = next_offset;
8951                } else {
8952                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8953                    inner_depth.increment()?;
8954                }
8955                let val_ref = self.service_uuid.get_or_insert_with(|| {
8956                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D)
8957                });
8958                fidl::decode!(
8959                    fidl_fuchsia_bluetooth__common::Uuid,
8960                    D,
8961                    val_ref,
8962                    decoder,
8963                    inner_offset,
8964                    inner_depth
8965                )?;
8966                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8967                {
8968                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8969                }
8970                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8971                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8972                }
8973            }
8974
8975            next_offset += envelope_size;
8976            _next_ordinal_to_read += 1;
8977            if next_offset >= end_offset {
8978                return Ok(());
8979            }
8980
8981            // Decode unknown envelopes for gaps in ordinals.
8982            while _next_ordinal_to_read < 2 {
8983                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8984                _next_ordinal_to_read += 1;
8985                next_offset += envelope_size;
8986            }
8987
8988            let next_out_of_line = decoder.next_out_of_line();
8989            let handles_before = decoder.remaining_handles();
8990            if let Some((inlined, num_bytes, num_handles)) =
8991                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8992            {
8993                let member_inline_size = <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8994                if inlined != (member_inline_size <= 4) {
8995                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8996                }
8997                let inner_offset;
8998                let mut inner_depth = depth.clone();
8999                if inlined {
9000                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9001                    inner_offset = next_offset;
9002                } else {
9003                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9004                    inner_depth.increment()?;
9005                }
9006                let val_ref = self.service_data_uuid.get_or_insert_with(|| {
9007                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D)
9008                });
9009                fidl::decode!(
9010                    fidl_fuchsia_bluetooth__common::Uuid,
9011                    D,
9012                    val_ref,
9013                    decoder,
9014                    inner_offset,
9015                    inner_depth
9016                )?;
9017                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9018                {
9019                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9020                }
9021                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9022                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9023                }
9024            }
9025
9026            next_offset += envelope_size;
9027            _next_ordinal_to_read += 1;
9028            if next_offset >= end_offset {
9029                return Ok(());
9030            }
9031
9032            // Decode unknown envelopes for gaps in ordinals.
9033            while _next_ordinal_to_read < 3 {
9034                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9035                _next_ordinal_to_read += 1;
9036                next_offset += envelope_size;
9037            }
9038
9039            let next_out_of_line = decoder.next_out_of_line();
9040            let handles_before = decoder.remaining_handles();
9041            if let Some((inlined, num_bytes, num_handles)) =
9042                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9043            {
9044                let member_inline_size =
9045                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9046                if inlined != (member_inline_size <= 4) {
9047                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9048                }
9049                let inner_offset;
9050                let mut inner_depth = depth.clone();
9051                if inlined {
9052                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9053                    inner_offset = next_offset;
9054                } else {
9055                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9056                    inner_depth.increment()?;
9057                }
9058                let val_ref = self.manufacturer_id.get_or_insert_with(|| fidl::new_empty!(u16, D));
9059                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
9060                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9061                {
9062                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9063                }
9064                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9065                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9066                }
9067            }
9068
9069            next_offset += envelope_size;
9070            _next_ordinal_to_read += 1;
9071            if next_offset >= end_offset {
9072                return Ok(());
9073            }
9074
9075            // Decode unknown envelopes for gaps in ordinals.
9076            while _next_ordinal_to_read < 4 {
9077                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9078                _next_ordinal_to_read += 1;
9079                next_offset += envelope_size;
9080            }
9081
9082            let next_out_of_line = decoder.next_out_of_line();
9083            let handles_before = decoder.remaining_handles();
9084            if let Some((inlined, num_bytes, num_handles)) =
9085                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9086            {
9087                let member_inline_size =
9088                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9089                if inlined != (member_inline_size <= 4) {
9090                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9091                }
9092                let inner_offset;
9093                let mut inner_depth = depth.clone();
9094                if inlined {
9095                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9096                    inner_offset = next_offset;
9097                } else {
9098                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9099                    inner_depth.increment()?;
9100                }
9101                let val_ref = self.connectable.get_or_insert_with(|| fidl::new_empty!(bool, D));
9102                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
9103                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9104                {
9105                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9106                }
9107                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9108                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9109                }
9110            }
9111
9112            next_offset += envelope_size;
9113            _next_ordinal_to_read += 1;
9114            if next_offset >= end_offset {
9115                return Ok(());
9116            }
9117
9118            // Decode unknown envelopes for gaps in ordinals.
9119            while _next_ordinal_to_read < 5 {
9120                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9121                _next_ordinal_to_read += 1;
9122                next_offset += envelope_size;
9123            }
9124
9125            let next_out_of_line = decoder.next_out_of_line();
9126            let handles_before = decoder.remaining_handles();
9127            if let Some((inlined, num_bytes, num_handles)) =
9128                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9129            {
9130                let member_inline_size =
9131                    <fidl::encoding::BoundedString<248> as fidl::encoding::TypeMarker>::inline_size(
9132                        decoder.context,
9133                    );
9134                if inlined != (member_inline_size <= 4) {
9135                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9136                }
9137                let inner_offset;
9138                let mut inner_depth = depth.clone();
9139                if inlined {
9140                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9141                    inner_offset = next_offset;
9142                } else {
9143                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9144                    inner_depth.increment()?;
9145                }
9146                let val_ref = self
9147                    .name
9148                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<248>, D));
9149                fidl::decode!(
9150                    fidl::encoding::BoundedString<248>,
9151                    D,
9152                    val_ref,
9153                    decoder,
9154                    inner_offset,
9155                    inner_depth
9156                )?;
9157                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9158                {
9159                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9160                }
9161                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9162                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9163                }
9164            }
9165
9166            next_offset += envelope_size;
9167            _next_ordinal_to_read += 1;
9168            if next_offset >= end_offset {
9169                return Ok(());
9170            }
9171
9172            // Decode unknown envelopes for gaps in ordinals.
9173            while _next_ordinal_to_read < 6 {
9174                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9175                _next_ordinal_to_read += 1;
9176                next_offset += envelope_size;
9177            }
9178
9179            let next_out_of_line = decoder.next_out_of_line();
9180            let handles_before = decoder.remaining_handles();
9181            if let Some((inlined, num_bytes, num_handles)) =
9182                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9183            {
9184                let member_inline_size =
9185                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9186                if inlined != (member_inline_size <= 4) {
9187                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9188                }
9189                let inner_offset;
9190                let mut inner_depth = depth.clone();
9191                if inlined {
9192                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9193                    inner_offset = next_offset;
9194                } else {
9195                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9196                    inner_depth.increment()?;
9197                }
9198                let val_ref = self.max_path_loss.get_or_insert_with(|| fidl::new_empty!(i8, D));
9199                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
9200                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9201                {
9202                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9203                }
9204                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9205                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9206                }
9207            }
9208
9209            next_offset += envelope_size;
9210            _next_ordinal_to_read += 1;
9211            if next_offset >= end_offset {
9212                return Ok(());
9213            }
9214
9215            // Decode unknown envelopes for gaps in ordinals.
9216            while _next_ordinal_to_read < 7 {
9217                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9218                _next_ordinal_to_read += 1;
9219                next_offset += envelope_size;
9220            }
9221
9222            let next_out_of_line = decoder.next_out_of_line();
9223            let handles_before = decoder.remaining_handles();
9224            if let Some((inlined, num_bytes, num_handles)) =
9225                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9226            {
9227                let member_inline_size = <fidl_fuchsia_bluetooth__common::Uuid as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9228                if inlined != (member_inline_size <= 4) {
9229                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9230                }
9231                let inner_offset;
9232                let mut inner_depth = depth.clone();
9233                if inlined {
9234                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9235                    inner_offset = next_offset;
9236                } else {
9237                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9238                    inner_depth.increment()?;
9239                }
9240                let val_ref = self.solicitation_uuid.get_or_insert_with(|| {
9241                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::Uuid, D)
9242                });
9243                fidl::decode!(
9244                    fidl_fuchsia_bluetooth__common::Uuid,
9245                    D,
9246                    val_ref,
9247                    decoder,
9248                    inner_offset,
9249                    inner_depth
9250                )?;
9251                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9252                {
9253                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9254                }
9255                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9256                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9257                }
9258            }
9259
9260            next_offset += envelope_size;
9261
9262            // Decode the remaining unknown envelopes.
9263            while next_offset < end_offset {
9264                _next_ordinal_to_read += 1;
9265                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9266                next_offset += envelope_size;
9267            }
9268
9269            Ok(())
9270        }
9271    }
9272
9273    impl IsochronousStreamOnEstablishedRequest {
9274        #[inline(always)]
9275        fn max_ordinal_present(&self) -> u64 {
9276            if let Some(_) = self.established_params {
9277                return 2;
9278            }
9279            if let Some(_) = self.result {
9280                return 1;
9281            }
9282            0
9283        }
9284    }
9285
9286    impl fidl::encoding::ValueTypeMarker for IsochronousStreamOnEstablishedRequest {
9287        type Borrowed<'a> = &'a Self;
9288        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9289            value
9290        }
9291    }
9292
9293    unsafe impl fidl::encoding::TypeMarker for IsochronousStreamOnEstablishedRequest {
9294        type Owned = Self;
9295
9296        #[inline(always)]
9297        fn inline_align(_context: fidl::encoding::Context) -> usize {
9298            8
9299        }
9300
9301        #[inline(always)]
9302        fn inline_size(_context: fidl::encoding::Context) -> usize {
9303            16
9304        }
9305    }
9306
9307    unsafe impl<D: fidl::encoding::ResourceDialect>
9308        fidl::encoding::Encode<IsochronousStreamOnEstablishedRequest, D>
9309        for &IsochronousStreamOnEstablishedRequest
9310    {
9311        unsafe fn encode(
9312            self,
9313            encoder: &mut fidl::encoding::Encoder<'_, D>,
9314            offset: usize,
9315            mut depth: fidl::encoding::Depth,
9316        ) -> fidl::Result<()> {
9317            encoder.debug_check_bounds::<IsochronousStreamOnEstablishedRequest>(offset);
9318            // Vector header
9319            let max_ordinal: u64 = self.max_ordinal_present();
9320            encoder.write_num(max_ordinal, offset);
9321            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9322            // Calling encoder.out_of_line_offset(0) is not allowed.
9323            if max_ordinal == 0 {
9324                return Ok(());
9325            }
9326            depth.increment()?;
9327            let envelope_size = 8;
9328            let bytes_len = max_ordinal as usize * envelope_size;
9329            #[allow(unused_variables)]
9330            let offset = encoder.out_of_line_offset(bytes_len);
9331            let mut _prev_end_offset: usize = 0;
9332            if 1 > max_ordinal {
9333                return Ok(());
9334            }
9335
9336            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9337            // are envelope_size bytes.
9338            let cur_offset: usize = (1 - 1) * envelope_size;
9339
9340            // Zero reserved fields.
9341            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9342
9343            // Safety:
9344            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9345            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9346            //   envelope_size bytes, there is always sufficient room.
9347            fidl::encoding::encode_in_envelope_optional::<i32, D>(
9348                self.result.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
9349                encoder,
9350                offset + cur_offset,
9351                depth,
9352            )?;
9353
9354            _prev_end_offset = cur_offset + envelope_size;
9355            if 2 > max_ordinal {
9356                return Ok(());
9357            }
9358
9359            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9360            // are envelope_size bytes.
9361            let cur_offset: usize = (2 - 1) * envelope_size;
9362
9363            // Zero reserved fields.
9364            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9365
9366            // Safety:
9367            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9368            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9369            //   envelope_size bytes, there is always sufficient room.
9370            fidl::encoding::encode_in_envelope_optional::<CisEstablishedParameters, D>(
9371                self.established_params
9372                    .as_ref()
9373                    .map(<CisEstablishedParameters as fidl::encoding::ValueTypeMarker>::borrow),
9374                encoder,
9375                offset + cur_offset,
9376                depth,
9377            )?;
9378
9379            _prev_end_offset = cur_offset + envelope_size;
9380
9381            Ok(())
9382        }
9383    }
9384
9385    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9386        for IsochronousStreamOnEstablishedRequest
9387    {
9388        #[inline(always)]
9389        fn new_empty() -> Self {
9390            Self::default()
9391        }
9392
9393        unsafe fn decode(
9394            &mut self,
9395            decoder: &mut fidl::encoding::Decoder<'_, D>,
9396            offset: usize,
9397            mut depth: fidl::encoding::Depth,
9398        ) -> fidl::Result<()> {
9399            decoder.debug_check_bounds::<Self>(offset);
9400            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9401                None => return Err(fidl::Error::NotNullable),
9402                Some(len) => len,
9403            };
9404            // Calling decoder.out_of_line_offset(0) is not allowed.
9405            if len == 0 {
9406                return Ok(());
9407            };
9408            depth.increment()?;
9409            let envelope_size = 8;
9410            let bytes_len = len * envelope_size;
9411            let offset = decoder.out_of_line_offset(bytes_len)?;
9412            // Decode the envelope for each type.
9413            let mut _next_ordinal_to_read = 0;
9414            let mut next_offset = offset;
9415            let end_offset = offset + bytes_len;
9416            _next_ordinal_to_read += 1;
9417            if next_offset >= end_offset {
9418                return Ok(());
9419            }
9420
9421            // Decode unknown envelopes for gaps in ordinals.
9422            while _next_ordinal_to_read < 1 {
9423                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9424                _next_ordinal_to_read += 1;
9425                next_offset += envelope_size;
9426            }
9427
9428            let next_out_of_line = decoder.next_out_of_line();
9429            let handles_before = decoder.remaining_handles();
9430            if let Some((inlined, num_bytes, num_handles)) =
9431                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9432            {
9433                let member_inline_size =
9434                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9435                if inlined != (member_inline_size <= 4) {
9436                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9437                }
9438                let inner_offset;
9439                let mut inner_depth = depth.clone();
9440                if inlined {
9441                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9442                    inner_offset = next_offset;
9443                } else {
9444                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9445                    inner_depth.increment()?;
9446                }
9447                let val_ref = self.result.get_or_insert_with(|| fidl::new_empty!(i32, D));
9448                fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
9449                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9450                {
9451                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9452                }
9453                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9454                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9455                }
9456            }
9457
9458            next_offset += envelope_size;
9459            _next_ordinal_to_read += 1;
9460            if next_offset >= end_offset {
9461                return Ok(());
9462            }
9463
9464            // Decode unknown envelopes for gaps in ordinals.
9465            while _next_ordinal_to_read < 2 {
9466                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9467                _next_ordinal_to_read += 1;
9468                next_offset += envelope_size;
9469            }
9470
9471            let next_out_of_line = decoder.next_out_of_line();
9472            let handles_before = decoder.remaining_handles();
9473            if let Some((inlined, num_bytes, num_handles)) =
9474                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9475            {
9476                let member_inline_size =
9477                    <CisEstablishedParameters as fidl::encoding::TypeMarker>::inline_size(
9478                        decoder.context,
9479                    );
9480                if inlined != (member_inline_size <= 4) {
9481                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9482                }
9483                let inner_offset;
9484                let mut inner_depth = depth.clone();
9485                if inlined {
9486                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9487                    inner_offset = next_offset;
9488                } else {
9489                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9490                    inner_depth.increment()?;
9491                }
9492                let val_ref = self
9493                    .established_params
9494                    .get_or_insert_with(|| fidl::new_empty!(CisEstablishedParameters, D));
9495                fidl::decode!(
9496                    CisEstablishedParameters,
9497                    D,
9498                    val_ref,
9499                    decoder,
9500                    inner_offset,
9501                    inner_depth
9502                )?;
9503                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9504                {
9505                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9506                }
9507                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9508                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9509                }
9510            }
9511
9512            next_offset += envelope_size;
9513
9514            // Decode the remaining unknown envelopes.
9515            while next_offset < end_offset {
9516                _next_ordinal_to_read += 1;
9517                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9518                next_offset += envelope_size;
9519            }
9520
9521            Ok(())
9522        }
9523    }
9524
9525    impl IsochronousStreamSetupDataPathRequest {
9526        #[inline(always)]
9527        fn max_ordinal_present(&self) -> u64 {
9528            if let Some(_) = self.controller_delay {
9529                return 3;
9530            }
9531            if let Some(_) = self.codec_attributes {
9532                return 2;
9533            }
9534            if let Some(_) = self.data_direction {
9535                return 1;
9536            }
9537            0
9538        }
9539    }
9540
9541    impl fidl::encoding::ValueTypeMarker for IsochronousStreamSetupDataPathRequest {
9542        type Borrowed<'a> = &'a Self;
9543        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9544            value
9545        }
9546    }
9547
9548    unsafe impl fidl::encoding::TypeMarker for IsochronousStreamSetupDataPathRequest {
9549        type Owned = Self;
9550
9551        #[inline(always)]
9552        fn inline_align(_context: fidl::encoding::Context) -> usize {
9553            8
9554        }
9555
9556        #[inline(always)]
9557        fn inline_size(_context: fidl::encoding::Context) -> usize {
9558            16
9559        }
9560    }
9561
9562    unsafe impl<D: fidl::encoding::ResourceDialect>
9563        fidl::encoding::Encode<IsochronousStreamSetupDataPathRequest, D>
9564        for &IsochronousStreamSetupDataPathRequest
9565    {
9566        unsafe fn encode(
9567            self,
9568            encoder: &mut fidl::encoding::Encoder<'_, D>,
9569            offset: usize,
9570            mut depth: fidl::encoding::Depth,
9571        ) -> fidl::Result<()> {
9572            encoder.debug_check_bounds::<IsochronousStreamSetupDataPathRequest>(offset);
9573            // Vector header
9574            let max_ordinal: u64 = self.max_ordinal_present();
9575            encoder.write_num(max_ordinal, offset);
9576            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9577            // Calling encoder.out_of_line_offset(0) is not allowed.
9578            if max_ordinal == 0 {
9579                return Ok(());
9580            }
9581            depth.increment()?;
9582            let envelope_size = 8;
9583            let bytes_len = max_ordinal as usize * envelope_size;
9584            #[allow(unused_variables)]
9585            let offset = encoder.out_of_line_offset(bytes_len);
9586            let mut _prev_end_offset: usize = 0;
9587            if 1 > max_ordinal {
9588                return Ok(());
9589            }
9590
9591            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9592            // are envelope_size bytes.
9593            let cur_offset: usize = (1 - 1) * envelope_size;
9594
9595            // Zero reserved fields.
9596            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9597
9598            // Safety:
9599            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9600            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9601            //   envelope_size bytes, there is always sufficient room.
9602            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::DataDirection, D>(
9603            self.data_direction.as_ref().map(<fidl_fuchsia_bluetooth__common::DataDirection as fidl::encoding::ValueTypeMarker>::borrow),
9604            encoder, offset + cur_offset, depth
9605        )?;
9606
9607            _prev_end_offset = cur_offset + envelope_size;
9608            if 2 > max_ordinal {
9609                return Ok(());
9610            }
9611
9612            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9613            // are envelope_size bytes.
9614            let cur_offset: usize = (2 - 1) * envelope_size;
9615
9616            // Zero reserved fields.
9617            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9618
9619            // Safety:
9620            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9621            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9622            //   envelope_size bytes, there is always sufficient room.
9623            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::CodecAttributes, D>(
9624            self.codec_attributes.as_ref().map(<fidl_fuchsia_bluetooth__common::CodecAttributes as fidl::encoding::ValueTypeMarker>::borrow),
9625            encoder, offset + cur_offset, depth
9626        )?;
9627
9628            _prev_end_offset = cur_offset + envelope_size;
9629            if 3 > max_ordinal {
9630                return Ok(());
9631            }
9632
9633            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9634            // are envelope_size bytes.
9635            let cur_offset: usize = (3 - 1) * envelope_size;
9636
9637            // Zero reserved fields.
9638            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9639
9640            // Safety:
9641            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9642            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9643            //   envelope_size bytes, there is always sufficient room.
9644            fidl::encoding::encode_in_envelope_optional::<i64, D>(
9645                self.controller_delay
9646                    .as_ref()
9647                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
9648                encoder,
9649                offset + cur_offset,
9650                depth,
9651            )?;
9652
9653            _prev_end_offset = cur_offset + envelope_size;
9654
9655            Ok(())
9656        }
9657    }
9658
9659    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9660        for IsochronousStreamSetupDataPathRequest
9661    {
9662        #[inline(always)]
9663        fn new_empty() -> Self {
9664            Self::default()
9665        }
9666
9667        unsafe fn decode(
9668            &mut self,
9669            decoder: &mut fidl::encoding::Decoder<'_, D>,
9670            offset: usize,
9671            mut depth: fidl::encoding::Depth,
9672        ) -> fidl::Result<()> {
9673            decoder.debug_check_bounds::<Self>(offset);
9674            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9675                None => return Err(fidl::Error::NotNullable),
9676                Some(len) => len,
9677            };
9678            // Calling decoder.out_of_line_offset(0) is not allowed.
9679            if len == 0 {
9680                return Ok(());
9681            };
9682            depth.increment()?;
9683            let envelope_size = 8;
9684            let bytes_len = len * envelope_size;
9685            let offset = decoder.out_of_line_offset(bytes_len)?;
9686            // Decode the envelope for each type.
9687            let mut _next_ordinal_to_read = 0;
9688            let mut next_offset = offset;
9689            let end_offset = offset + bytes_len;
9690            _next_ordinal_to_read += 1;
9691            if next_offset >= end_offset {
9692                return Ok(());
9693            }
9694
9695            // Decode unknown envelopes for gaps in ordinals.
9696            while _next_ordinal_to_read < 1 {
9697                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9698                _next_ordinal_to_read += 1;
9699                next_offset += envelope_size;
9700            }
9701
9702            let next_out_of_line = decoder.next_out_of_line();
9703            let handles_before = decoder.remaining_handles();
9704            if let Some((inlined, num_bytes, num_handles)) =
9705                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9706            {
9707                let member_inline_size = <fidl_fuchsia_bluetooth__common::DataDirection as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9708                if inlined != (member_inline_size <= 4) {
9709                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9710                }
9711                let inner_offset;
9712                let mut inner_depth = depth.clone();
9713                if inlined {
9714                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9715                    inner_offset = next_offset;
9716                } else {
9717                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9718                    inner_depth.increment()?;
9719                }
9720                let val_ref = self.data_direction.get_or_insert_with(|| {
9721                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::DataDirection, D)
9722                });
9723                fidl::decode!(
9724                    fidl_fuchsia_bluetooth__common::DataDirection,
9725                    D,
9726                    val_ref,
9727                    decoder,
9728                    inner_offset,
9729                    inner_depth
9730                )?;
9731                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9732                {
9733                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9734                }
9735                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9736                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9737                }
9738            }
9739
9740            next_offset += envelope_size;
9741            _next_ordinal_to_read += 1;
9742            if next_offset >= end_offset {
9743                return Ok(());
9744            }
9745
9746            // Decode unknown envelopes for gaps in ordinals.
9747            while _next_ordinal_to_read < 2 {
9748                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9749                _next_ordinal_to_read += 1;
9750                next_offset += envelope_size;
9751            }
9752
9753            let next_out_of_line = decoder.next_out_of_line();
9754            let handles_before = decoder.remaining_handles();
9755            if let Some((inlined, num_bytes, num_handles)) =
9756                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9757            {
9758                let member_inline_size = <fidl_fuchsia_bluetooth__common::CodecAttributes as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9759                if inlined != (member_inline_size <= 4) {
9760                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9761                }
9762                let inner_offset;
9763                let mut inner_depth = depth.clone();
9764                if inlined {
9765                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9766                    inner_offset = next_offset;
9767                } else {
9768                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9769                    inner_depth.increment()?;
9770                }
9771                let val_ref = self.codec_attributes.get_or_insert_with(|| {
9772                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::CodecAttributes, D)
9773                });
9774                fidl::decode!(
9775                    fidl_fuchsia_bluetooth__common::CodecAttributes,
9776                    D,
9777                    val_ref,
9778                    decoder,
9779                    inner_offset,
9780                    inner_depth
9781                )?;
9782                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9783                {
9784                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9785                }
9786                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9787                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9788                }
9789            }
9790
9791            next_offset += envelope_size;
9792            _next_ordinal_to_read += 1;
9793            if next_offset >= end_offset {
9794                return Ok(());
9795            }
9796
9797            // Decode unknown envelopes for gaps in ordinals.
9798            while _next_ordinal_to_read < 3 {
9799                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9800                _next_ordinal_to_read += 1;
9801                next_offset += envelope_size;
9802            }
9803
9804            let next_out_of_line = decoder.next_out_of_line();
9805            let handles_before = decoder.remaining_handles();
9806            if let Some((inlined, num_bytes, num_handles)) =
9807                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9808            {
9809                let member_inline_size =
9810                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9811                if inlined != (member_inline_size <= 4) {
9812                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9813                }
9814                let inner_offset;
9815                let mut inner_depth = depth.clone();
9816                if inlined {
9817                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9818                    inner_offset = next_offset;
9819                } else {
9820                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9821                    inner_depth.increment()?;
9822                }
9823                let val_ref = self.controller_delay.get_or_insert_with(|| fidl::new_empty!(i64, D));
9824                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
9825                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9826                {
9827                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9828                }
9829                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9830                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9831                }
9832            }
9833
9834            next_offset += envelope_size;
9835
9836            // Decode the remaining unknown envelopes.
9837            while next_offset < end_offset {
9838                _next_ordinal_to_read += 1;
9839                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9840                next_offset += envelope_size;
9841            }
9842
9843            Ok(())
9844        }
9845    }
9846
9847    impl IsochronousStreamWriteRequest {
9848        #[inline(always)]
9849        fn max_ordinal_present(&self) -> u64 {
9850            if let Some(_) = self.data {
9851                return 1;
9852            }
9853            0
9854        }
9855    }
9856
9857    impl fidl::encoding::ValueTypeMarker for IsochronousStreamWriteRequest {
9858        type Borrowed<'a> = &'a Self;
9859        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9860            value
9861        }
9862    }
9863
9864    unsafe impl fidl::encoding::TypeMarker for IsochronousStreamWriteRequest {
9865        type Owned = Self;
9866
9867        #[inline(always)]
9868        fn inline_align(_context: fidl::encoding::Context) -> usize {
9869            8
9870        }
9871
9872        #[inline(always)]
9873        fn inline_size(_context: fidl::encoding::Context) -> usize {
9874            16
9875        }
9876    }
9877
9878    unsafe impl<D: fidl::encoding::ResourceDialect>
9879        fidl::encoding::Encode<IsochronousStreamWriteRequest, D>
9880        for &IsochronousStreamWriteRequest
9881    {
9882        unsafe fn encode(
9883            self,
9884            encoder: &mut fidl::encoding::Encoder<'_, D>,
9885            offset: usize,
9886            mut depth: fidl::encoding::Depth,
9887        ) -> fidl::Result<()> {
9888            encoder.debug_check_bounds::<IsochronousStreamWriteRequest>(offset);
9889            // Vector header
9890            let max_ordinal: u64 = self.max_ordinal_present();
9891            encoder.write_num(max_ordinal, offset);
9892            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9893            // Calling encoder.out_of_line_offset(0) is not allowed.
9894            if max_ordinal == 0 {
9895                return Ok(());
9896            }
9897            depth.increment()?;
9898            let envelope_size = 8;
9899            let bytes_len = max_ordinal as usize * envelope_size;
9900            #[allow(unused_variables)]
9901            let offset = encoder.out_of_line_offset(bytes_len);
9902            let mut _prev_end_offset: usize = 0;
9903            if 1 > max_ordinal {
9904                return Ok(());
9905            }
9906
9907            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9908            // are envelope_size bytes.
9909            let cur_offset: usize = (1 - 1) * envelope_size;
9910
9911            // Zero reserved fields.
9912            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9913
9914            // Safety:
9915            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9916            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9917            //   envelope_size bytes, there is always sufficient room.
9918            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 4095>, D>(
9919                self.data.as_ref().map(
9920                    <fidl::encoding::Vector<u8, 4095> as fidl::encoding::ValueTypeMarker>::borrow,
9921                ),
9922                encoder,
9923                offset + cur_offset,
9924                depth,
9925            )?;
9926
9927            _prev_end_offset = cur_offset + envelope_size;
9928
9929            Ok(())
9930        }
9931    }
9932
9933    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
9934        for IsochronousStreamWriteRequest
9935    {
9936        #[inline(always)]
9937        fn new_empty() -> Self {
9938            Self::default()
9939        }
9940
9941        unsafe fn decode(
9942            &mut self,
9943            decoder: &mut fidl::encoding::Decoder<'_, D>,
9944            offset: usize,
9945            mut depth: fidl::encoding::Depth,
9946        ) -> fidl::Result<()> {
9947            decoder.debug_check_bounds::<Self>(offset);
9948            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9949                None => return Err(fidl::Error::NotNullable),
9950                Some(len) => len,
9951            };
9952            // Calling decoder.out_of_line_offset(0) is not allowed.
9953            if len == 0 {
9954                return Ok(());
9955            };
9956            depth.increment()?;
9957            let envelope_size = 8;
9958            let bytes_len = len * envelope_size;
9959            let offset = decoder.out_of_line_offset(bytes_len)?;
9960            // Decode the envelope for each type.
9961            let mut _next_ordinal_to_read = 0;
9962            let mut next_offset = offset;
9963            let end_offset = offset + bytes_len;
9964            _next_ordinal_to_read += 1;
9965            if next_offset >= end_offset {
9966                return Ok(());
9967            }
9968
9969            // Decode unknown envelopes for gaps in ordinals.
9970            while _next_ordinal_to_read < 1 {
9971                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9972                _next_ordinal_to_read += 1;
9973                next_offset += envelope_size;
9974            }
9975
9976            let next_out_of_line = decoder.next_out_of_line();
9977            let handles_before = decoder.remaining_handles();
9978            if let Some((inlined, num_bytes, num_handles)) =
9979                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9980            {
9981                let member_inline_size =
9982                    <fidl::encoding::Vector<u8, 4095> as fidl::encoding::TypeMarker>::inline_size(
9983                        decoder.context,
9984                    );
9985                if inlined != (member_inline_size <= 4) {
9986                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9987                }
9988                let inner_offset;
9989                let mut inner_depth = depth.clone();
9990                if inlined {
9991                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9992                    inner_offset = next_offset;
9993                } else {
9994                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9995                    inner_depth.increment()?;
9996                }
9997                let val_ref = self
9998                    .data
9999                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 4095>, D));
10000                fidl::decode!(fidl::encoding::Vector<u8, 4095>, D, val_ref, decoder, inner_offset, inner_depth)?;
10001                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10002                {
10003                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10004                }
10005                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10006                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10007                }
10008            }
10009
10010            next_offset += envelope_size;
10011
10012            // Decode the remaining unknown envelopes.
10013            while next_offset < end_offset {
10014                _next_ordinal_to_read += 1;
10015                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10016                next_offset += envelope_size;
10017            }
10018
10019            Ok(())
10020        }
10021    }
10022
10023    impl IsochronousStreamReadResponse {
10024        #[inline(always)]
10025        fn max_ordinal_present(&self) -> u64 {
10026            if let Some(_) = self.timestamp {
10027                return 4;
10028            }
10029            if let Some(_) = self.status_flag {
10030                return 3;
10031            }
10032            if let Some(_) = self.sequence_number {
10033                return 2;
10034            }
10035            if let Some(_) = self.data {
10036                return 1;
10037            }
10038            0
10039        }
10040    }
10041
10042    impl fidl::encoding::ValueTypeMarker for IsochronousStreamReadResponse {
10043        type Borrowed<'a> = &'a Self;
10044        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10045            value
10046        }
10047    }
10048
10049    unsafe impl fidl::encoding::TypeMarker for IsochronousStreamReadResponse {
10050        type Owned = Self;
10051
10052        #[inline(always)]
10053        fn inline_align(_context: fidl::encoding::Context) -> usize {
10054            8
10055        }
10056
10057        #[inline(always)]
10058        fn inline_size(_context: fidl::encoding::Context) -> usize {
10059            16
10060        }
10061    }
10062
10063    unsafe impl<D: fidl::encoding::ResourceDialect>
10064        fidl::encoding::Encode<IsochronousStreamReadResponse, D>
10065        for &IsochronousStreamReadResponse
10066    {
10067        unsafe fn encode(
10068            self,
10069            encoder: &mut fidl::encoding::Encoder<'_, D>,
10070            offset: usize,
10071            mut depth: fidl::encoding::Depth,
10072        ) -> fidl::Result<()> {
10073            encoder.debug_check_bounds::<IsochronousStreamReadResponse>(offset);
10074            // Vector header
10075            let max_ordinal: u64 = self.max_ordinal_present();
10076            encoder.write_num(max_ordinal, offset);
10077            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10078            // Calling encoder.out_of_line_offset(0) is not allowed.
10079            if max_ordinal == 0 {
10080                return Ok(());
10081            }
10082            depth.increment()?;
10083            let envelope_size = 8;
10084            let bytes_len = max_ordinal as usize * envelope_size;
10085            #[allow(unused_variables)]
10086            let offset = encoder.out_of_line_offset(bytes_len);
10087            let mut _prev_end_offset: usize = 0;
10088            if 1 > max_ordinal {
10089                return Ok(());
10090            }
10091
10092            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10093            // are envelope_size bytes.
10094            let cur_offset: usize = (1 - 1) * envelope_size;
10095
10096            // Zero reserved fields.
10097            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10098
10099            // Safety:
10100            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10101            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10102            //   envelope_size bytes, there is always sufficient room.
10103            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
10104            self.data.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
10105            encoder, offset + cur_offset, depth
10106        )?;
10107
10108            _prev_end_offset = cur_offset + envelope_size;
10109            if 2 > max_ordinal {
10110                return Ok(());
10111            }
10112
10113            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10114            // are envelope_size bytes.
10115            let cur_offset: usize = (2 - 1) * envelope_size;
10116
10117            // Zero reserved fields.
10118            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10119
10120            // Safety:
10121            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10122            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10123            //   envelope_size bytes, there is always sufficient room.
10124            fidl::encoding::encode_in_envelope_optional::<u16, D>(
10125                self.sequence_number.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
10126                encoder,
10127                offset + cur_offset,
10128                depth,
10129            )?;
10130
10131            _prev_end_offset = cur_offset + envelope_size;
10132            if 3 > max_ordinal {
10133                return Ok(());
10134            }
10135
10136            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10137            // are envelope_size bytes.
10138            let cur_offset: usize = (3 - 1) * envelope_size;
10139
10140            // Zero reserved fields.
10141            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10142
10143            // Safety:
10144            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10145            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10146            //   envelope_size bytes, there is always sufficient room.
10147            fidl::encoding::encode_in_envelope_optional::<IsoPacketStatusFlag, D>(
10148                self.status_flag
10149                    .as_ref()
10150                    .map(<IsoPacketStatusFlag as fidl::encoding::ValueTypeMarker>::borrow),
10151                encoder,
10152                offset + cur_offset,
10153                depth,
10154            )?;
10155
10156            _prev_end_offset = cur_offset + envelope_size;
10157            if 4 > max_ordinal {
10158                return Ok(());
10159            }
10160
10161            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10162            // are envelope_size bytes.
10163            let cur_offset: usize = (4 - 1) * envelope_size;
10164
10165            // Zero reserved fields.
10166            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10167
10168            // Safety:
10169            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10170            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10171            //   envelope_size bytes, there is always sufficient room.
10172            fidl::encoding::encode_in_envelope_optional::<i64, D>(
10173                self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
10174                encoder,
10175                offset + cur_offset,
10176                depth,
10177            )?;
10178
10179            _prev_end_offset = cur_offset + envelope_size;
10180
10181            Ok(())
10182        }
10183    }
10184
10185    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
10186        for IsochronousStreamReadResponse
10187    {
10188        #[inline(always)]
10189        fn new_empty() -> Self {
10190            Self::default()
10191        }
10192
10193        unsafe fn decode(
10194            &mut self,
10195            decoder: &mut fidl::encoding::Decoder<'_, D>,
10196            offset: usize,
10197            mut depth: fidl::encoding::Depth,
10198        ) -> fidl::Result<()> {
10199            decoder.debug_check_bounds::<Self>(offset);
10200            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10201                None => return Err(fidl::Error::NotNullable),
10202                Some(len) => len,
10203            };
10204            // Calling decoder.out_of_line_offset(0) is not allowed.
10205            if len == 0 {
10206                return Ok(());
10207            };
10208            depth.increment()?;
10209            let envelope_size = 8;
10210            let bytes_len = len * envelope_size;
10211            let offset = decoder.out_of_line_offset(bytes_len)?;
10212            // Decode the envelope for each type.
10213            let mut _next_ordinal_to_read = 0;
10214            let mut next_offset = offset;
10215            let end_offset = offset + bytes_len;
10216            _next_ordinal_to_read += 1;
10217            if next_offset >= end_offset {
10218                return Ok(());
10219            }
10220
10221            // Decode unknown envelopes for gaps in ordinals.
10222            while _next_ordinal_to_read < 1 {
10223                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10224                _next_ordinal_to_read += 1;
10225                next_offset += envelope_size;
10226            }
10227
10228            let next_out_of_line = decoder.next_out_of_line();
10229            let handles_before = decoder.remaining_handles();
10230            if let Some((inlined, num_bytes, num_handles)) =
10231                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10232            {
10233                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10234                if inlined != (member_inline_size <= 4) {
10235                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10236                }
10237                let inner_offset;
10238                let mut inner_depth = depth.clone();
10239                if inlined {
10240                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10241                    inner_offset = next_offset;
10242                } else {
10243                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10244                    inner_depth.increment()?;
10245                }
10246                let val_ref = self.data.get_or_insert_with(|| {
10247                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
10248                });
10249                fidl::decode!(
10250                    fidl::encoding::UnboundedVector<u8>,
10251                    D,
10252                    val_ref,
10253                    decoder,
10254                    inner_offset,
10255                    inner_depth
10256                )?;
10257                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10258                {
10259                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10260                }
10261                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10262                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10263                }
10264            }
10265
10266            next_offset += envelope_size;
10267            _next_ordinal_to_read += 1;
10268            if next_offset >= end_offset {
10269                return Ok(());
10270            }
10271
10272            // Decode unknown envelopes for gaps in ordinals.
10273            while _next_ordinal_to_read < 2 {
10274                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10275                _next_ordinal_to_read += 1;
10276                next_offset += envelope_size;
10277            }
10278
10279            let next_out_of_line = decoder.next_out_of_line();
10280            let handles_before = decoder.remaining_handles();
10281            if let Some((inlined, num_bytes, num_handles)) =
10282                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10283            {
10284                let member_inline_size =
10285                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10286                if inlined != (member_inline_size <= 4) {
10287                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10288                }
10289                let inner_offset;
10290                let mut inner_depth = depth.clone();
10291                if inlined {
10292                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10293                    inner_offset = next_offset;
10294                } else {
10295                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10296                    inner_depth.increment()?;
10297                }
10298                let val_ref = self.sequence_number.get_or_insert_with(|| fidl::new_empty!(u16, D));
10299                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
10300                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10301                {
10302                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10303                }
10304                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10305                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10306                }
10307            }
10308
10309            next_offset += envelope_size;
10310            _next_ordinal_to_read += 1;
10311            if next_offset >= end_offset {
10312                return Ok(());
10313            }
10314
10315            // Decode unknown envelopes for gaps in ordinals.
10316            while _next_ordinal_to_read < 3 {
10317                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10318                _next_ordinal_to_read += 1;
10319                next_offset += envelope_size;
10320            }
10321
10322            let next_out_of_line = decoder.next_out_of_line();
10323            let handles_before = decoder.remaining_handles();
10324            if let Some((inlined, num_bytes, num_handles)) =
10325                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10326            {
10327                let member_inline_size =
10328                    <IsoPacketStatusFlag as fidl::encoding::TypeMarker>::inline_size(
10329                        decoder.context,
10330                    );
10331                if inlined != (member_inline_size <= 4) {
10332                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10333                }
10334                let inner_offset;
10335                let mut inner_depth = depth.clone();
10336                if inlined {
10337                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10338                    inner_offset = next_offset;
10339                } else {
10340                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10341                    inner_depth.increment()?;
10342                }
10343                let val_ref = self
10344                    .status_flag
10345                    .get_or_insert_with(|| fidl::new_empty!(IsoPacketStatusFlag, D));
10346                fidl::decode!(IsoPacketStatusFlag, D, val_ref, decoder, inner_offset, inner_depth)?;
10347                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10348                {
10349                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10350                }
10351                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10352                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10353                }
10354            }
10355
10356            next_offset += envelope_size;
10357            _next_ordinal_to_read += 1;
10358            if next_offset >= end_offset {
10359                return Ok(());
10360            }
10361
10362            // Decode unknown envelopes for gaps in ordinals.
10363            while _next_ordinal_to_read < 4 {
10364                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10365                _next_ordinal_to_read += 1;
10366                next_offset += envelope_size;
10367            }
10368
10369            let next_out_of_line = decoder.next_out_of_line();
10370            let handles_before = decoder.remaining_handles();
10371            if let Some((inlined, num_bytes, num_handles)) =
10372                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10373            {
10374                let member_inline_size =
10375                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10376                if inlined != (member_inline_size <= 4) {
10377                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10378                }
10379                let inner_offset;
10380                let mut inner_depth = depth.clone();
10381                if inlined {
10382                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10383                    inner_offset = next_offset;
10384                } else {
10385                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10386                    inner_depth.increment()?;
10387                }
10388                let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
10389                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
10390                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10391                {
10392                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10393                }
10394                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10395                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10396                }
10397            }
10398
10399            next_offset += envelope_size;
10400
10401            // Decode the remaining unknown envelopes.
10402            while next_offset < end_offset {
10403                _next_ordinal_to_read += 1;
10404                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10405                next_offset += envelope_size;
10406            }
10407
10408            Ok(())
10409        }
10410    }
10411
10412    impl Legacy {
10413        #[inline(always)]
10414        fn max_ordinal_present(&self) -> u64 {
10415            0
10416        }
10417    }
10418
10419    impl fidl::encoding::ValueTypeMarker for Legacy {
10420        type Borrowed<'a> = &'a Self;
10421        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10422            value
10423        }
10424    }
10425
10426    unsafe impl fidl::encoding::TypeMarker for Legacy {
10427        type Owned = Self;
10428
10429        #[inline(always)]
10430        fn inline_align(_context: fidl::encoding::Context) -> usize {
10431            8
10432        }
10433
10434        #[inline(always)]
10435        fn inline_size(_context: fidl::encoding::Context) -> usize {
10436            16
10437        }
10438    }
10439
10440    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Legacy, D> for &Legacy {
10441        unsafe fn encode(
10442            self,
10443            encoder: &mut fidl::encoding::Encoder<'_, D>,
10444            offset: usize,
10445            mut depth: fidl::encoding::Depth,
10446        ) -> fidl::Result<()> {
10447            encoder.debug_check_bounds::<Legacy>(offset);
10448            // Vector header
10449            let max_ordinal: u64 = self.max_ordinal_present();
10450            encoder.write_num(max_ordinal, offset);
10451            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10452            // Calling encoder.out_of_line_offset(0) is not allowed.
10453            if max_ordinal == 0 {
10454                return Ok(());
10455            }
10456            depth.increment()?;
10457            let envelope_size = 8;
10458            let bytes_len = max_ordinal as usize * envelope_size;
10459            #[allow(unused_variables)]
10460            let offset = encoder.out_of_line_offset(bytes_len);
10461            let mut _prev_end_offset: usize = 0;
10462
10463            Ok(())
10464        }
10465    }
10466
10467    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Legacy {
10468        #[inline(always)]
10469        fn new_empty() -> Self {
10470            Self::default()
10471        }
10472
10473        unsafe fn decode(
10474            &mut self,
10475            decoder: &mut fidl::encoding::Decoder<'_, D>,
10476            offset: usize,
10477            mut depth: fidl::encoding::Depth,
10478        ) -> fidl::Result<()> {
10479            decoder.debug_check_bounds::<Self>(offset);
10480            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10481                None => return Err(fidl::Error::NotNullable),
10482                Some(len) => len,
10483            };
10484            // Calling decoder.out_of_line_offset(0) is not allowed.
10485            if len == 0 {
10486                return Ok(());
10487            };
10488            depth.increment()?;
10489            let envelope_size = 8;
10490            let bytes_len = len * envelope_size;
10491            let offset = decoder.out_of_line_offset(bytes_len)?;
10492            // Decode the envelope for each type.
10493            let mut _next_ordinal_to_read = 0;
10494            let mut next_offset = offset;
10495            let end_offset = offset + bytes_len;
10496
10497            // Decode the remaining unknown envelopes.
10498            while next_offset < end_offset {
10499                _next_ordinal_to_read += 1;
10500                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10501                next_offset += envelope_size;
10502            }
10503
10504            Ok(())
10505        }
10506    }
10507
10508    impl Peer {
10509        #[inline(always)]
10510        fn max_ordinal_present(&self) -> u64 {
10511            if let Some(_) = self.periodic_advertising_interval {
10512                return 10;
10513            }
10514            if let Some(_) = self.advertising_sid {
10515                return 9;
10516            }
10517            if let Some(_) = self.last_updated {
10518                return 8;
10519            }
10520            if let Some(_) = self.bonded {
10521                return 7;
10522            }
10523            if let Some(_) = self.data {
10524                return 6;
10525            }
10526            if let Some(_) = self.name {
10527                return 5;
10528            }
10529            if let Some(_) = self.advertising_data {
10530                return 4;
10531            }
10532            if let Some(_) = self.rssi {
10533                return 3;
10534            }
10535            if let Some(_) = self.connectable {
10536                return 2;
10537            }
10538            if let Some(_) = self.id {
10539                return 1;
10540            }
10541            0
10542        }
10543    }
10544
10545    impl fidl::encoding::ValueTypeMarker for Peer {
10546        type Borrowed<'a> = &'a Self;
10547        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10548            value
10549        }
10550    }
10551
10552    unsafe impl fidl::encoding::TypeMarker for Peer {
10553        type Owned = Self;
10554
10555        #[inline(always)]
10556        fn inline_align(_context: fidl::encoding::Context) -> usize {
10557            8
10558        }
10559
10560        #[inline(always)]
10561        fn inline_size(_context: fidl::encoding::Context) -> usize {
10562            16
10563        }
10564    }
10565
10566    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Peer, D> for &Peer {
10567        unsafe fn encode(
10568            self,
10569            encoder: &mut fidl::encoding::Encoder<'_, D>,
10570            offset: usize,
10571            mut depth: fidl::encoding::Depth,
10572        ) -> fidl::Result<()> {
10573            encoder.debug_check_bounds::<Peer>(offset);
10574            // Vector header
10575            let max_ordinal: u64 = self.max_ordinal_present();
10576            encoder.write_num(max_ordinal, offset);
10577            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10578            // Calling encoder.out_of_line_offset(0) is not allowed.
10579            if max_ordinal == 0 {
10580                return Ok(());
10581            }
10582            depth.increment()?;
10583            let envelope_size = 8;
10584            let bytes_len = max_ordinal as usize * envelope_size;
10585            #[allow(unused_variables)]
10586            let offset = encoder.out_of_line_offset(bytes_len);
10587            let mut _prev_end_offset: usize = 0;
10588            if 1 > max_ordinal {
10589                return Ok(());
10590            }
10591
10592            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10593            // are envelope_size bytes.
10594            let cur_offset: usize = (1 - 1) * envelope_size;
10595
10596            // Zero reserved fields.
10597            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10598
10599            // Safety:
10600            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10601            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10602            //   envelope_size bytes, there is always sufficient room.
10603            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::PeerId, D>(
10604            self.id.as_ref().map(<fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::ValueTypeMarker>::borrow),
10605            encoder, offset + cur_offset, depth
10606        )?;
10607
10608            _prev_end_offset = cur_offset + envelope_size;
10609            if 2 > max_ordinal {
10610                return Ok(());
10611            }
10612
10613            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10614            // are envelope_size bytes.
10615            let cur_offset: usize = (2 - 1) * envelope_size;
10616
10617            // Zero reserved fields.
10618            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10619
10620            // Safety:
10621            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10622            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10623            //   envelope_size bytes, there is always sufficient room.
10624            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10625                self.connectable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10626                encoder,
10627                offset + cur_offset,
10628                depth,
10629            )?;
10630
10631            _prev_end_offset = cur_offset + envelope_size;
10632            if 3 > max_ordinal {
10633                return Ok(());
10634            }
10635
10636            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10637            // are envelope_size bytes.
10638            let cur_offset: usize = (3 - 1) * envelope_size;
10639
10640            // Zero reserved fields.
10641            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10642
10643            // Safety:
10644            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10645            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10646            //   envelope_size bytes, there is always sufficient room.
10647            fidl::encoding::encode_in_envelope_optional::<i8, D>(
10648                self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
10649                encoder,
10650                offset + cur_offset,
10651                depth,
10652            )?;
10653
10654            _prev_end_offset = cur_offset + envelope_size;
10655            if 4 > max_ordinal {
10656                return Ok(());
10657            }
10658
10659            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10660            // are envelope_size bytes.
10661            let cur_offset: usize = (4 - 1) * envelope_size;
10662
10663            // Zero reserved fields.
10664            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10665
10666            // Safety:
10667            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10668            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10669            //   envelope_size bytes, there is always sufficient room.
10670            fidl::encoding::encode_in_envelope_optional::<AdvertisingData, D>(
10671                self.advertising_data
10672                    .as_ref()
10673                    .map(<AdvertisingData as fidl::encoding::ValueTypeMarker>::borrow),
10674                encoder,
10675                offset + cur_offset,
10676                depth,
10677            )?;
10678
10679            _prev_end_offset = cur_offset + envelope_size;
10680            if 5 > 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 = (5 - 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::<fidl::encoding::BoundedString<248>, D>(
10696                self.name.as_ref().map(
10697                    <fidl::encoding::BoundedString<248> as fidl::encoding::ValueTypeMarker>::borrow,
10698                ),
10699                encoder,
10700                offset + cur_offset,
10701                depth,
10702            )?;
10703
10704            _prev_end_offset = cur_offset + envelope_size;
10705            if 6 > max_ordinal {
10706                return Ok(());
10707            }
10708
10709            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10710            // are envelope_size bytes.
10711            let cur_offset: usize = (6 - 1) * envelope_size;
10712
10713            // Zero reserved fields.
10714            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10715
10716            // Safety:
10717            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10718            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10719            //   envelope_size bytes, there is always sufficient room.
10720            fidl::encoding::encode_in_envelope_optional::<ScanData, D>(
10721                self.data.as_ref().map(<ScanData as fidl::encoding::ValueTypeMarker>::borrow),
10722                encoder,
10723                offset + cur_offset,
10724                depth,
10725            )?;
10726
10727            _prev_end_offset = cur_offset + envelope_size;
10728            if 7 > max_ordinal {
10729                return Ok(());
10730            }
10731
10732            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10733            // are envelope_size bytes.
10734            let cur_offset: usize = (7 - 1) * envelope_size;
10735
10736            // Zero reserved fields.
10737            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10738
10739            // Safety:
10740            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10741            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10742            //   envelope_size bytes, there is always sufficient room.
10743            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10744                self.bonded.as_ref().map(<bool 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 8 > 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 = (8 - 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::<i64, D>(
10767                self.last_updated.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
10768                encoder,
10769                offset + cur_offset,
10770                depth,
10771            )?;
10772
10773            _prev_end_offset = cur_offset + envelope_size;
10774            if 9 > max_ordinal {
10775                return Ok(());
10776            }
10777
10778            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10779            // are envelope_size bytes.
10780            let cur_offset: usize = (9 - 1) * envelope_size;
10781
10782            // Zero reserved fields.
10783            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10784
10785            // Safety:
10786            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10787            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10788            //   envelope_size bytes, there is always sufficient room.
10789            fidl::encoding::encode_in_envelope_optional::<u8, D>(
10790                self.advertising_sid.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
10791                encoder,
10792                offset + cur_offset,
10793                depth,
10794            )?;
10795
10796            _prev_end_offset = cur_offset + envelope_size;
10797            if 10 > max_ordinal {
10798                return Ok(());
10799            }
10800
10801            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10802            // are envelope_size bytes.
10803            let cur_offset: usize = (10 - 1) * envelope_size;
10804
10805            // Zero reserved fields.
10806            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10807
10808            // Safety:
10809            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10810            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10811            //   envelope_size bytes, there is always sufficient room.
10812            fidl::encoding::encode_in_envelope_optional::<u16, D>(
10813                self.periodic_advertising_interval
10814                    .as_ref()
10815                    .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
10816                encoder,
10817                offset + cur_offset,
10818                depth,
10819            )?;
10820
10821            _prev_end_offset = cur_offset + envelope_size;
10822
10823            Ok(())
10824        }
10825    }
10826
10827    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Peer {
10828        #[inline(always)]
10829        fn new_empty() -> Self {
10830            Self::default()
10831        }
10832
10833        unsafe fn decode(
10834            &mut self,
10835            decoder: &mut fidl::encoding::Decoder<'_, D>,
10836            offset: usize,
10837            mut depth: fidl::encoding::Depth,
10838        ) -> fidl::Result<()> {
10839            decoder.debug_check_bounds::<Self>(offset);
10840            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10841                None => return Err(fidl::Error::NotNullable),
10842                Some(len) => len,
10843            };
10844            // Calling decoder.out_of_line_offset(0) is not allowed.
10845            if len == 0 {
10846                return Ok(());
10847            };
10848            depth.increment()?;
10849            let envelope_size = 8;
10850            let bytes_len = len * envelope_size;
10851            let offset = decoder.out_of_line_offset(bytes_len)?;
10852            // Decode the envelope for each type.
10853            let mut _next_ordinal_to_read = 0;
10854            let mut next_offset = offset;
10855            let end_offset = offset + bytes_len;
10856            _next_ordinal_to_read += 1;
10857            if next_offset >= end_offset {
10858                return Ok(());
10859            }
10860
10861            // Decode unknown envelopes for gaps in ordinals.
10862            while _next_ordinal_to_read < 1 {
10863                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10864                _next_ordinal_to_read += 1;
10865                next_offset += envelope_size;
10866            }
10867
10868            let next_out_of_line = decoder.next_out_of_line();
10869            let handles_before = decoder.remaining_handles();
10870            if let Some((inlined, num_bytes, num_handles)) =
10871                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10872            {
10873                let member_inline_size = <fidl_fuchsia_bluetooth__common::PeerId as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10874                if inlined != (member_inline_size <= 4) {
10875                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10876                }
10877                let inner_offset;
10878                let mut inner_depth = depth.clone();
10879                if inlined {
10880                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10881                    inner_offset = next_offset;
10882                } else {
10883                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10884                    inner_depth.increment()?;
10885                }
10886                let val_ref = self.id.get_or_insert_with(|| {
10887                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::PeerId, D)
10888                });
10889                fidl::decode!(
10890                    fidl_fuchsia_bluetooth__common::PeerId,
10891                    D,
10892                    val_ref,
10893                    decoder,
10894                    inner_offset,
10895                    inner_depth
10896                )?;
10897                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10898                {
10899                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10900                }
10901                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10902                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10903                }
10904            }
10905
10906            next_offset += envelope_size;
10907            _next_ordinal_to_read += 1;
10908            if next_offset >= end_offset {
10909                return Ok(());
10910            }
10911
10912            // Decode unknown envelopes for gaps in ordinals.
10913            while _next_ordinal_to_read < 2 {
10914                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10915                _next_ordinal_to_read += 1;
10916                next_offset += envelope_size;
10917            }
10918
10919            let next_out_of_line = decoder.next_out_of_line();
10920            let handles_before = decoder.remaining_handles();
10921            if let Some((inlined, num_bytes, num_handles)) =
10922                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10923            {
10924                let member_inline_size =
10925                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10926                if inlined != (member_inline_size <= 4) {
10927                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10928                }
10929                let inner_offset;
10930                let mut inner_depth = depth.clone();
10931                if inlined {
10932                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10933                    inner_offset = next_offset;
10934                } else {
10935                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10936                    inner_depth.increment()?;
10937                }
10938                let val_ref = self.connectable.get_or_insert_with(|| fidl::new_empty!(bool, D));
10939                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10940                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10941                {
10942                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10943                }
10944                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10945                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10946                }
10947            }
10948
10949            next_offset += envelope_size;
10950            _next_ordinal_to_read += 1;
10951            if next_offset >= end_offset {
10952                return Ok(());
10953            }
10954
10955            // Decode unknown envelopes for gaps in ordinals.
10956            while _next_ordinal_to_read < 3 {
10957                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10958                _next_ordinal_to_read += 1;
10959                next_offset += envelope_size;
10960            }
10961
10962            let next_out_of_line = decoder.next_out_of_line();
10963            let handles_before = decoder.remaining_handles();
10964            if let Some((inlined, num_bytes, num_handles)) =
10965                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10966            {
10967                let member_inline_size =
10968                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10969                if inlined != (member_inline_size <= 4) {
10970                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10971                }
10972                let inner_offset;
10973                let mut inner_depth = depth.clone();
10974                if inlined {
10975                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10976                    inner_offset = next_offset;
10977                } else {
10978                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10979                    inner_depth.increment()?;
10980                }
10981                let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
10982                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
10983                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10984                {
10985                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10986                }
10987                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10988                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10989                }
10990            }
10991
10992            next_offset += envelope_size;
10993            _next_ordinal_to_read += 1;
10994            if next_offset >= end_offset {
10995                return Ok(());
10996            }
10997
10998            // Decode unknown envelopes for gaps in ordinals.
10999            while _next_ordinal_to_read < 4 {
11000                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11001                _next_ordinal_to_read += 1;
11002                next_offset += envelope_size;
11003            }
11004
11005            let next_out_of_line = decoder.next_out_of_line();
11006            let handles_before = decoder.remaining_handles();
11007            if let Some((inlined, num_bytes, num_handles)) =
11008                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11009            {
11010                let member_inline_size =
11011                    <AdvertisingData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11012                if inlined != (member_inline_size <= 4) {
11013                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11014                }
11015                let inner_offset;
11016                let mut inner_depth = depth.clone();
11017                if inlined {
11018                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11019                    inner_offset = next_offset;
11020                } else {
11021                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11022                    inner_depth.increment()?;
11023                }
11024                let val_ref = self
11025                    .advertising_data
11026                    .get_or_insert_with(|| fidl::new_empty!(AdvertisingData, D));
11027                fidl::decode!(AdvertisingData, D, val_ref, decoder, inner_offset, inner_depth)?;
11028                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11029                {
11030                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11031                }
11032                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11033                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11034                }
11035            }
11036
11037            next_offset += envelope_size;
11038            _next_ordinal_to_read += 1;
11039            if next_offset >= end_offset {
11040                return Ok(());
11041            }
11042
11043            // Decode unknown envelopes for gaps in ordinals.
11044            while _next_ordinal_to_read < 5 {
11045                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11046                _next_ordinal_to_read += 1;
11047                next_offset += envelope_size;
11048            }
11049
11050            let next_out_of_line = decoder.next_out_of_line();
11051            let handles_before = decoder.remaining_handles();
11052            if let Some((inlined, num_bytes, num_handles)) =
11053                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11054            {
11055                let member_inline_size =
11056                    <fidl::encoding::BoundedString<248> as fidl::encoding::TypeMarker>::inline_size(
11057                        decoder.context,
11058                    );
11059                if inlined != (member_inline_size <= 4) {
11060                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11061                }
11062                let inner_offset;
11063                let mut inner_depth = depth.clone();
11064                if inlined {
11065                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11066                    inner_offset = next_offset;
11067                } else {
11068                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11069                    inner_depth.increment()?;
11070                }
11071                let val_ref = self
11072                    .name
11073                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<248>, D));
11074                fidl::decode!(
11075                    fidl::encoding::BoundedString<248>,
11076                    D,
11077                    val_ref,
11078                    decoder,
11079                    inner_offset,
11080                    inner_depth
11081                )?;
11082                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11083                {
11084                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11085                }
11086                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11087                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11088                }
11089            }
11090
11091            next_offset += envelope_size;
11092            _next_ordinal_to_read += 1;
11093            if next_offset >= end_offset {
11094                return Ok(());
11095            }
11096
11097            // Decode unknown envelopes for gaps in ordinals.
11098            while _next_ordinal_to_read < 6 {
11099                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11100                _next_ordinal_to_read += 1;
11101                next_offset += envelope_size;
11102            }
11103
11104            let next_out_of_line = decoder.next_out_of_line();
11105            let handles_before = decoder.remaining_handles();
11106            if let Some((inlined, num_bytes, num_handles)) =
11107                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11108            {
11109                let member_inline_size =
11110                    <ScanData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11111                if inlined != (member_inline_size <= 4) {
11112                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11113                }
11114                let inner_offset;
11115                let mut inner_depth = depth.clone();
11116                if inlined {
11117                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11118                    inner_offset = next_offset;
11119                } else {
11120                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11121                    inner_depth.increment()?;
11122                }
11123                let val_ref = self.data.get_or_insert_with(|| fidl::new_empty!(ScanData, D));
11124                fidl::decode!(ScanData, D, val_ref, decoder, inner_offset, inner_depth)?;
11125                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11126                {
11127                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11128                }
11129                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11130                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11131                }
11132            }
11133
11134            next_offset += envelope_size;
11135            _next_ordinal_to_read += 1;
11136            if next_offset >= end_offset {
11137                return Ok(());
11138            }
11139
11140            // Decode unknown envelopes for gaps in ordinals.
11141            while _next_ordinal_to_read < 7 {
11142                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11143                _next_ordinal_to_read += 1;
11144                next_offset += envelope_size;
11145            }
11146
11147            let next_out_of_line = decoder.next_out_of_line();
11148            let handles_before = decoder.remaining_handles();
11149            if let Some((inlined, num_bytes, num_handles)) =
11150                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11151            {
11152                let member_inline_size =
11153                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11154                if inlined != (member_inline_size <= 4) {
11155                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11156                }
11157                let inner_offset;
11158                let mut inner_depth = depth.clone();
11159                if inlined {
11160                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11161                    inner_offset = next_offset;
11162                } else {
11163                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11164                    inner_depth.increment()?;
11165                }
11166                let val_ref = self.bonded.get_or_insert_with(|| fidl::new_empty!(bool, D));
11167                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
11168                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11169                {
11170                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11171                }
11172                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11173                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11174                }
11175            }
11176
11177            next_offset += envelope_size;
11178            _next_ordinal_to_read += 1;
11179            if next_offset >= end_offset {
11180                return Ok(());
11181            }
11182
11183            // Decode unknown envelopes for gaps in ordinals.
11184            while _next_ordinal_to_read < 8 {
11185                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11186                _next_ordinal_to_read += 1;
11187                next_offset += envelope_size;
11188            }
11189
11190            let next_out_of_line = decoder.next_out_of_line();
11191            let handles_before = decoder.remaining_handles();
11192            if let Some((inlined, num_bytes, num_handles)) =
11193                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11194            {
11195                let member_inline_size =
11196                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11197                if inlined != (member_inline_size <= 4) {
11198                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11199                }
11200                let inner_offset;
11201                let mut inner_depth = depth.clone();
11202                if inlined {
11203                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11204                    inner_offset = next_offset;
11205                } else {
11206                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11207                    inner_depth.increment()?;
11208                }
11209                let val_ref = self.last_updated.get_or_insert_with(|| fidl::new_empty!(i64, D));
11210                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
11211                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11212                {
11213                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11214                }
11215                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11216                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11217                }
11218            }
11219
11220            next_offset += envelope_size;
11221            _next_ordinal_to_read += 1;
11222            if next_offset >= end_offset {
11223                return Ok(());
11224            }
11225
11226            // Decode unknown envelopes for gaps in ordinals.
11227            while _next_ordinal_to_read < 9 {
11228                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11229                _next_ordinal_to_read += 1;
11230                next_offset += envelope_size;
11231            }
11232
11233            let next_out_of_line = decoder.next_out_of_line();
11234            let handles_before = decoder.remaining_handles();
11235            if let Some((inlined, num_bytes, num_handles)) =
11236                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11237            {
11238                let member_inline_size =
11239                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11240                if inlined != (member_inline_size <= 4) {
11241                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11242                }
11243                let inner_offset;
11244                let mut inner_depth = depth.clone();
11245                if inlined {
11246                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11247                    inner_offset = next_offset;
11248                } else {
11249                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11250                    inner_depth.increment()?;
11251                }
11252                let val_ref = self.advertising_sid.get_or_insert_with(|| fidl::new_empty!(u8, D));
11253                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
11254                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11255                {
11256                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11257                }
11258                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11259                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11260                }
11261            }
11262
11263            next_offset += envelope_size;
11264            _next_ordinal_to_read += 1;
11265            if next_offset >= end_offset {
11266                return Ok(());
11267            }
11268
11269            // Decode unknown envelopes for gaps in ordinals.
11270            while _next_ordinal_to_read < 10 {
11271                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11272                _next_ordinal_to_read += 1;
11273                next_offset += envelope_size;
11274            }
11275
11276            let next_out_of_line = decoder.next_out_of_line();
11277            let handles_before = decoder.remaining_handles();
11278            if let Some((inlined, num_bytes, num_handles)) =
11279                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11280            {
11281                let member_inline_size =
11282                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11283                if inlined != (member_inline_size <= 4) {
11284                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11285                }
11286                let inner_offset;
11287                let mut inner_depth = depth.clone();
11288                if inlined {
11289                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11290                    inner_offset = next_offset;
11291                } else {
11292                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11293                    inner_depth.increment()?;
11294                }
11295                let val_ref = self
11296                    .periodic_advertising_interval
11297                    .get_or_insert_with(|| fidl::new_empty!(u16, D));
11298                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
11299                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11300                {
11301                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11302                }
11303                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11304                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11305                }
11306            }
11307
11308            next_offset += envelope_size;
11309
11310            // Decode the remaining unknown envelopes.
11311            while next_offset < end_offset {
11312                _next_ordinal_to_read += 1;
11313                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11314                next_offset += envelope_size;
11315            }
11316
11317            Ok(())
11318        }
11319    }
11320
11321    impl ScanData {
11322        #[inline(always)]
11323        fn max_ordinal_present(&self) -> u64 {
11324            if let Some(_) = self.timestamp {
11325                return 7;
11326            }
11327            if let Some(_) = self.uris {
11328                return 6;
11329            }
11330            if let Some(_) = self.manufacturer_data {
11331                return 5;
11332            }
11333            if let Some(_) = self.service_data {
11334                return 4;
11335            }
11336            if let Some(_) = self.service_uuids {
11337                return 3;
11338            }
11339            if let Some(_) = self.appearance {
11340                return 2;
11341            }
11342            if let Some(_) = self.tx_power {
11343                return 1;
11344            }
11345            0
11346        }
11347    }
11348
11349    impl fidl::encoding::ValueTypeMarker for ScanData {
11350        type Borrowed<'a> = &'a Self;
11351        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11352            value
11353        }
11354    }
11355
11356    unsafe impl fidl::encoding::TypeMarker for ScanData {
11357        type Owned = Self;
11358
11359        #[inline(always)]
11360        fn inline_align(_context: fidl::encoding::Context) -> usize {
11361            8
11362        }
11363
11364        #[inline(always)]
11365        fn inline_size(_context: fidl::encoding::Context) -> usize {
11366            16
11367        }
11368    }
11369
11370    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ScanData, D> for &ScanData {
11371        unsafe fn encode(
11372            self,
11373            encoder: &mut fidl::encoding::Encoder<'_, D>,
11374            offset: usize,
11375            mut depth: fidl::encoding::Depth,
11376        ) -> fidl::Result<()> {
11377            encoder.debug_check_bounds::<ScanData>(offset);
11378            // Vector header
11379            let max_ordinal: u64 = self.max_ordinal_present();
11380            encoder.write_num(max_ordinal, offset);
11381            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11382            // Calling encoder.out_of_line_offset(0) is not allowed.
11383            if max_ordinal == 0 {
11384                return Ok(());
11385            }
11386            depth.increment()?;
11387            let envelope_size = 8;
11388            let bytes_len = max_ordinal as usize * envelope_size;
11389            #[allow(unused_variables)]
11390            let offset = encoder.out_of_line_offset(bytes_len);
11391            let mut _prev_end_offset: usize = 0;
11392            if 1 > max_ordinal {
11393                return Ok(());
11394            }
11395
11396            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11397            // are envelope_size bytes.
11398            let cur_offset: usize = (1 - 1) * envelope_size;
11399
11400            // Zero reserved fields.
11401            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11402
11403            // Safety:
11404            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11405            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11406            //   envelope_size bytes, there is always sufficient room.
11407            fidl::encoding::encode_in_envelope_optional::<i8, D>(
11408                self.tx_power.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
11409                encoder,
11410                offset + cur_offset,
11411                depth,
11412            )?;
11413
11414            _prev_end_offset = cur_offset + envelope_size;
11415            if 2 > max_ordinal {
11416                return Ok(());
11417            }
11418
11419            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11420            // are envelope_size bytes.
11421            let cur_offset: usize = (2 - 1) * envelope_size;
11422
11423            // Zero reserved fields.
11424            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11425
11426            // Safety:
11427            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11428            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11429            //   envelope_size bytes, there is always sufficient room.
11430            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_bluetooth__common::Appearance, D>(
11431            self.appearance.as_ref().map(<fidl_fuchsia_bluetooth__common::Appearance as fidl::encoding::ValueTypeMarker>::borrow),
11432            encoder, offset + cur_offset, depth
11433        )?;
11434
11435            _prev_end_offset = cur_offset + envelope_size;
11436            if 3 > max_ordinal {
11437                return Ok(());
11438            }
11439
11440            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11441            // are envelope_size bytes.
11442            let cur_offset: usize = (3 - 1) * envelope_size;
11443
11444            // Zero reserved fields.
11445            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11446
11447            // Safety:
11448            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11449            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11450            //   envelope_size bytes, there is always sufficient room.
11451            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>, D>(
11452            self.service_uuids.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid> as fidl::encoding::ValueTypeMarker>::borrow),
11453            encoder, offset + cur_offset, depth
11454        )?;
11455
11456            _prev_end_offset = cur_offset + envelope_size;
11457            if 4 > max_ordinal {
11458                return Ok(());
11459            }
11460
11461            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11462            // are envelope_size bytes.
11463            let cur_offset: usize = (4 - 1) * envelope_size;
11464
11465            // Zero reserved fields.
11466            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11467
11468            // Safety:
11469            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11470            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11471            //   envelope_size bytes, there is always sufficient room.
11472            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ServiceData>, D>(
11473            self.service_data.as_ref().map(<fidl::encoding::UnboundedVector<ServiceData> as fidl::encoding::ValueTypeMarker>::borrow),
11474            encoder, offset + cur_offset, depth
11475        )?;
11476
11477            _prev_end_offset = cur_offset + envelope_size;
11478            if 5 > max_ordinal {
11479                return Ok(());
11480            }
11481
11482            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11483            // are envelope_size bytes.
11484            let cur_offset: usize = (5 - 1) * envelope_size;
11485
11486            // Zero reserved fields.
11487            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11488
11489            // Safety:
11490            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11491            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11492            //   envelope_size bytes, there is always sufficient room.
11493            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<ManufacturerData>, D>(
11494            self.manufacturer_data.as_ref().map(<fidl::encoding::UnboundedVector<ManufacturerData> as fidl::encoding::ValueTypeMarker>::borrow),
11495            encoder, offset + cur_offset, depth
11496        )?;
11497
11498            _prev_end_offset = cur_offset + envelope_size;
11499            if 6 > max_ordinal {
11500                return Ok(());
11501            }
11502
11503            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11504            // are envelope_size bytes.
11505            let cur_offset: usize = (6 - 1) * envelope_size;
11506
11507            // Zero reserved fields.
11508            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11509
11510            // Safety:
11511            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11512            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11513            //   envelope_size bytes, there is always sufficient room.
11514            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>, D>(
11515            self.uris.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>> as fidl::encoding::ValueTypeMarker>::borrow),
11516            encoder, offset + cur_offset, depth
11517        )?;
11518
11519            _prev_end_offset = cur_offset + envelope_size;
11520            if 7 > max_ordinal {
11521                return Ok(());
11522            }
11523
11524            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11525            // are envelope_size bytes.
11526            let cur_offset: usize = (7 - 1) * envelope_size;
11527
11528            // Zero reserved fields.
11529            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11530
11531            // Safety:
11532            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11533            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11534            //   envelope_size bytes, there is always sufficient room.
11535            fidl::encoding::encode_in_envelope_optional::<i64, D>(
11536                self.timestamp.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
11537                encoder,
11538                offset + cur_offset,
11539                depth,
11540            )?;
11541
11542            _prev_end_offset = cur_offset + envelope_size;
11543
11544            Ok(())
11545        }
11546    }
11547
11548    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanData {
11549        #[inline(always)]
11550        fn new_empty() -> Self {
11551            Self::default()
11552        }
11553
11554        unsafe fn decode(
11555            &mut self,
11556            decoder: &mut fidl::encoding::Decoder<'_, D>,
11557            offset: usize,
11558            mut depth: fidl::encoding::Depth,
11559        ) -> fidl::Result<()> {
11560            decoder.debug_check_bounds::<Self>(offset);
11561            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11562                None => return Err(fidl::Error::NotNullable),
11563                Some(len) => len,
11564            };
11565            // Calling decoder.out_of_line_offset(0) is not allowed.
11566            if len == 0 {
11567                return Ok(());
11568            };
11569            depth.increment()?;
11570            let envelope_size = 8;
11571            let bytes_len = len * envelope_size;
11572            let offset = decoder.out_of_line_offset(bytes_len)?;
11573            // Decode the envelope for each type.
11574            let mut _next_ordinal_to_read = 0;
11575            let mut next_offset = offset;
11576            let end_offset = offset + bytes_len;
11577            _next_ordinal_to_read += 1;
11578            if next_offset >= end_offset {
11579                return Ok(());
11580            }
11581
11582            // Decode unknown envelopes for gaps in ordinals.
11583            while _next_ordinal_to_read < 1 {
11584                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11585                _next_ordinal_to_read += 1;
11586                next_offset += envelope_size;
11587            }
11588
11589            let next_out_of_line = decoder.next_out_of_line();
11590            let handles_before = decoder.remaining_handles();
11591            if let Some((inlined, num_bytes, num_handles)) =
11592                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11593            {
11594                let member_inline_size =
11595                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11596                if inlined != (member_inline_size <= 4) {
11597                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11598                }
11599                let inner_offset;
11600                let mut inner_depth = depth.clone();
11601                if inlined {
11602                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11603                    inner_offset = next_offset;
11604                } else {
11605                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11606                    inner_depth.increment()?;
11607                }
11608                let val_ref = self.tx_power.get_or_insert_with(|| fidl::new_empty!(i8, D));
11609                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
11610                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11611                {
11612                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11613                }
11614                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11615                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11616                }
11617            }
11618
11619            next_offset += envelope_size;
11620            _next_ordinal_to_read += 1;
11621            if next_offset >= end_offset {
11622                return Ok(());
11623            }
11624
11625            // Decode unknown envelopes for gaps in ordinals.
11626            while _next_ordinal_to_read < 2 {
11627                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11628                _next_ordinal_to_read += 1;
11629                next_offset += envelope_size;
11630            }
11631
11632            let next_out_of_line = decoder.next_out_of_line();
11633            let handles_before = decoder.remaining_handles();
11634            if let Some((inlined, num_bytes, num_handles)) =
11635                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11636            {
11637                let member_inline_size = <fidl_fuchsia_bluetooth__common::Appearance as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11638                if inlined != (member_inline_size <= 4) {
11639                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11640                }
11641                let inner_offset;
11642                let mut inner_depth = depth.clone();
11643                if inlined {
11644                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11645                    inner_offset = next_offset;
11646                } else {
11647                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11648                    inner_depth.increment()?;
11649                }
11650                let val_ref = self.appearance.get_or_insert_with(|| {
11651                    fidl::new_empty!(fidl_fuchsia_bluetooth__common::Appearance, D)
11652                });
11653                fidl::decode!(
11654                    fidl_fuchsia_bluetooth__common::Appearance,
11655                    D,
11656                    val_ref,
11657                    decoder,
11658                    inner_offset,
11659                    inner_depth
11660                )?;
11661                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11662                {
11663                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11664                }
11665                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11666                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11667                }
11668            }
11669
11670            next_offset += envelope_size;
11671            _next_ordinal_to_read += 1;
11672            if next_offset >= end_offset {
11673                return Ok(());
11674            }
11675
11676            // Decode unknown envelopes for gaps in ordinals.
11677            while _next_ordinal_to_read < 3 {
11678                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11679                _next_ordinal_to_read += 1;
11680                next_offset += envelope_size;
11681            }
11682
11683            let next_out_of_line = decoder.next_out_of_line();
11684            let handles_before = decoder.remaining_handles();
11685            if let Some((inlined, num_bytes, num_handles)) =
11686                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11687            {
11688                let member_inline_size = <fidl::encoding::UnboundedVector<
11689                    fidl_fuchsia_bluetooth__common::Uuid,
11690                > as fidl::encoding::TypeMarker>::inline_size(
11691                    decoder.context
11692                );
11693                if inlined != (member_inline_size <= 4) {
11694                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11695                }
11696                let inner_offset;
11697                let mut inner_depth = depth.clone();
11698                if inlined {
11699                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11700                    inner_offset = next_offset;
11701                } else {
11702                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11703                    inner_depth.increment()?;
11704                }
11705                let val_ref = self.service_uuids.get_or_insert_with(|| {
11706                    fidl::new_empty!(
11707                        fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>,
11708                        D
11709                    )
11710                });
11711                fidl::decode!(
11712                    fidl::encoding::UnboundedVector<fidl_fuchsia_bluetooth__common::Uuid>,
11713                    D,
11714                    val_ref,
11715                    decoder,
11716                    inner_offset,
11717                    inner_depth
11718                )?;
11719                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11720                {
11721                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11722                }
11723                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11724                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11725                }
11726            }
11727
11728            next_offset += envelope_size;
11729            _next_ordinal_to_read += 1;
11730            if next_offset >= end_offset {
11731                return Ok(());
11732            }
11733
11734            // Decode unknown envelopes for gaps in ordinals.
11735            while _next_ordinal_to_read < 4 {
11736                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11737                _next_ordinal_to_read += 1;
11738                next_offset += envelope_size;
11739            }
11740
11741            let next_out_of_line = decoder.next_out_of_line();
11742            let handles_before = decoder.remaining_handles();
11743            if let Some((inlined, num_bytes, num_handles)) =
11744                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11745            {
11746                let member_inline_size = <fidl::encoding::UnboundedVector<ServiceData> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11747                if inlined != (member_inline_size <= 4) {
11748                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11749                }
11750                let inner_offset;
11751                let mut inner_depth = depth.clone();
11752                if inlined {
11753                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11754                    inner_offset = next_offset;
11755                } else {
11756                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11757                    inner_depth.increment()?;
11758                }
11759                let val_ref = self.service_data.get_or_insert_with(|| {
11760                    fidl::new_empty!(fidl::encoding::UnboundedVector<ServiceData>, D)
11761                });
11762                fidl::decode!(
11763                    fidl::encoding::UnboundedVector<ServiceData>,
11764                    D,
11765                    val_ref,
11766                    decoder,
11767                    inner_offset,
11768                    inner_depth
11769                )?;
11770                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11771                {
11772                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11773                }
11774                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11775                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11776                }
11777            }
11778
11779            next_offset += envelope_size;
11780            _next_ordinal_to_read += 1;
11781            if next_offset >= end_offset {
11782                return Ok(());
11783            }
11784
11785            // Decode unknown envelopes for gaps in ordinals.
11786            while _next_ordinal_to_read < 5 {
11787                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11788                _next_ordinal_to_read += 1;
11789                next_offset += envelope_size;
11790            }
11791
11792            let next_out_of_line = decoder.next_out_of_line();
11793            let handles_before = decoder.remaining_handles();
11794            if let Some((inlined, num_bytes, num_handles)) =
11795                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11796            {
11797                let member_inline_size = <fidl::encoding::UnboundedVector<ManufacturerData> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11798                if inlined != (member_inline_size <= 4) {
11799                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11800                }
11801                let inner_offset;
11802                let mut inner_depth = depth.clone();
11803                if inlined {
11804                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11805                    inner_offset = next_offset;
11806                } else {
11807                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11808                    inner_depth.increment()?;
11809                }
11810                let val_ref = self.manufacturer_data.get_or_insert_with(|| {
11811                    fidl::new_empty!(fidl::encoding::UnboundedVector<ManufacturerData>, D)
11812                });
11813                fidl::decode!(
11814                    fidl::encoding::UnboundedVector<ManufacturerData>,
11815                    D,
11816                    val_ref,
11817                    decoder,
11818                    inner_offset,
11819                    inner_depth
11820                )?;
11821                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11822                {
11823                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11824                }
11825                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11826                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11827                }
11828            }
11829
11830            next_offset += envelope_size;
11831            _next_ordinal_to_read += 1;
11832            if next_offset >= end_offset {
11833                return Ok(());
11834            }
11835
11836            // Decode unknown envelopes for gaps in ordinals.
11837            while _next_ordinal_to_read < 6 {
11838                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11839                _next_ordinal_to_read += 1;
11840                next_offset += envelope_size;
11841            }
11842
11843            let next_out_of_line = decoder.next_out_of_line();
11844            let handles_before = decoder.remaining_handles();
11845            if let Some((inlined, num_bytes, num_handles)) =
11846                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11847            {
11848                let member_inline_size = <fidl::encoding::UnboundedVector<
11849                    fidl::encoding::BoundedString<278>,
11850                > as fidl::encoding::TypeMarker>::inline_size(
11851                    decoder.context
11852                );
11853                if inlined != (member_inline_size <= 4) {
11854                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11855                }
11856                let inner_offset;
11857                let mut inner_depth = depth.clone();
11858                if inlined {
11859                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11860                    inner_offset = next_offset;
11861                } else {
11862                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11863                    inner_depth.increment()?;
11864                }
11865                let val_ref = self.uris.get_or_insert_with(|| {
11866                    fidl::new_empty!(
11867                        fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>,
11868                        D
11869                    )
11870                });
11871                fidl::decode!(
11872                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<278>>,
11873                    D,
11874                    val_ref,
11875                    decoder,
11876                    inner_offset,
11877                    inner_depth
11878                )?;
11879                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11880                {
11881                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11882                }
11883                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11884                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11885                }
11886            }
11887
11888            next_offset += envelope_size;
11889            _next_ordinal_to_read += 1;
11890            if next_offset >= end_offset {
11891                return Ok(());
11892            }
11893
11894            // Decode unknown envelopes for gaps in ordinals.
11895            while _next_ordinal_to_read < 7 {
11896                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11897                _next_ordinal_to_read += 1;
11898                next_offset += envelope_size;
11899            }
11900
11901            let next_out_of_line = decoder.next_out_of_line();
11902            let handles_before = decoder.remaining_handles();
11903            if let Some((inlined, num_bytes, num_handles)) =
11904                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11905            {
11906                let member_inline_size =
11907                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11908                if inlined != (member_inline_size <= 4) {
11909                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11910                }
11911                let inner_offset;
11912                let mut inner_depth = depth.clone();
11913                if inlined {
11914                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11915                    inner_offset = next_offset;
11916                } else {
11917                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11918                    inner_depth.increment()?;
11919                }
11920                let val_ref = self.timestamp.get_or_insert_with(|| fidl::new_empty!(i64, D));
11921                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
11922                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11923                {
11924                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11925                }
11926                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11927                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11928                }
11929            }
11930
11931            next_offset += envelope_size;
11932
11933            // Decode the remaining unknown envelopes.
11934            while next_offset < end_offset {
11935                _next_ordinal_to_read += 1;
11936                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11937                next_offset += envelope_size;
11938            }
11939
11940            Ok(())
11941        }
11942    }
11943
11944    impl ScanOptions {
11945        #[inline(always)]
11946        fn max_ordinal_present(&self) -> u64 {
11947            if let Some(_) = self.filters {
11948                return 1;
11949            }
11950            0
11951        }
11952    }
11953
11954    impl fidl::encoding::ValueTypeMarker for ScanOptions {
11955        type Borrowed<'a> = &'a Self;
11956        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11957            value
11958        }
11959    }
11960
11961    unsafe impl fidl::encoding::TypeMarker for ScanOptions {
11962        type Owned = Self;
11963
11964        #[inline(always)]
11965        fn inline_align(_context: fidl::encoding::Context) -> usize {
11966            8
11967        }
11968
11969        #[inline(always)]
11970        fn inline_size(_context: fidl::encoding::Context) -> usize {
11971            16
11972        }
11973    }
11974
11975    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ScanOptions, D>
11976        for &ScanOptions
11977    {
11978        unsafe fn encode(
11979            self,
11980            encoder: &mut fidl::encoding::Encoder<'_, D>,
11981            offset: usize,
11982            mut depth: fidl::encoding::Depth,
11983        ) -> fidl::Result<()> {
11984            encoder.debug_check_bounds::<ScanOptions>(offset);
11985            // Vector header
11986            let max_ordinal: u64 = self.max_ordinal_present();
11987            encoder.write_num(max_ordinal, offset);
11988            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11989            // Calling encoder.out_of_line_offset(0) is not allowed.
11990            if max_ordinal == 0 {
11991                return Ok(());
11992            }
11993            depth.increment()?;
11994            let envelope_size = 8;
11995            let bytes_len = max_ordinal as usize * envelope_size;
11996            #[allow(unused_variables)]
11997            let offset = encoder.out_of_line_offset(bytes_len);
11998            let mut _prev_end_offset: usize = 0;
11999            if 1 > max_ordinal {
12000                return Ok(());
12001            }
12002
12003            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12004            // are envelope_size bytes.
12005            let cur_offset: usize = (1 - 1) * envelope_size;
12006
12007            // Zero reserved fields.
12008            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12009
12010            // Safety:
12011            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12012            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12013            //   envelope_size bytes, there is always sufficient room.
12014            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Filter>, D>(
12015            self.filters.as_ref().map(<fidl::encoding::UnboundedVector<Filter> as fidl::encoding::ValueTypeMarker>::borrow),
12016            encoder, offset + cur_offset, depth
12017        )?;
12018
12019            _prev_end_offset = cur_offset + envelope_size;
12020
12021            Ok(())
12022        }
12023    }
12024
12025    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ScanOptions {
12026        #[inline(always)]
12027        fn new_empty() -> Self {
12028            Self::default()
12029        }
12030
12031        unsafe fn decode(
12032            &mut self,
12033            decoder: &mut fidl::encoding::Decoder<'_, D>,
12034            offset: usize,
12035            mut depth: fidl::encoding::Depth,
12036        ) -> fidl::Result<()> {
12037            decoder.debug_check_bounds::<Self>(offset);
12038            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12039                None => return Err(fidl::Error::NotNullable),
12040                Some(len) => len,
12041            };
12042            // Calling decoder.out_of_line_offset(0) is not allowed.
12043            if len == 0 {
12044                return Ok(());
12045            };
12046            depth.increment()?;
12047            let envelope_size = 8;
12048            let bytes_len = len * envelope_size;
12049            let offset = decoder.out_of_line_offset(bytes_len)?;
12050            // Decode the envelope for each type.
12051            let mut _next_ordinal_to_read = 0;
12052            let mut next_offset = offset;
12053            let end_offset = offset + bytes_len;
12054            _next_ordinal_to_read += 1;
12055            if next_offset >= end_offset {
12056                return Ok(());
12057            }
12058
12059            // Decode unknown envelopes for gaps in ordinals.
12060            while _next_ordinal_to_read < 1 {
12061                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12062                _next_ordinal_to_read += 1;
12063                next_offset += envelope_size;
12064            }
12065
12066            let next_out_of_line = decoder.next_out_of_line();
12067            let handles_before = decoder.remaining_handles();
12068            if let Some((inlined, num_bytes, num_handles)) =
12069                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12070            {
12071                let member_inline_size = <fidl::encoding::UnboundedVector<Filter> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12072                if inlined != (member_inline_size <= 4) {
12073                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12074                }
12075                let inner_offset;
12076                let mut inner_depth = depth.clone();
12077                if inlined {
12078                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12079                    inner_offset = next_offset;
12080                } else {
12081                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12082                    inner_depth.increment()?;
12083                }
12084                let val_ref = self.filters.get_or_insert_with(|| {
12085                    fidl::new_empty!(fidl::encoding::UnboundedVector<Filter>, D)
12086                });
12087                fidl::decode!(
12088                    fidl::encoding::UnboundedVector<Filter>,
12089                    D,
12090                    val_ref,
12091                    decoder,
12092                    inner_offset,
12093                    inner_depth
12094                )?;
12095                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12096                {
12097                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12098                }
12099                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12100                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12101                }
12102            }
12103
12104            next_offset += envelope_size;
12105
12106            // Decode the remaining unknown envelopes.
12107            while next_offset < end_offset {
12108                _next_ordinal_to_read += 1;
12109                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12110                next_offset += envelope_size;
12111            }
12112
12113            Ok(())
12114        }
12115    }
12116
12117    impl fidl::encoding::ValueTypeMarker for AdvertisingProcedure {
12118        type Borrowed<'a> = &'a Self;
12119        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12120            value
12121        }
12122    }
12123
12124    unsafe impl fidl::encoding::TypeMarker for AdvertisingProcedure {
12125        type Owned = Self;
12126
12127        #[inline(always)]
12128        fn inline_align(_context: fidl::encoding::Context) -> usize {
12129            8
12130        }
12131
12132        #[inline(always)]
12133        fn inline_size(_context: fidl::encoding::Context) -> usize {
12134            16
12135        }
12136    }
12137
12138    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AdvertisingProcedure, D>
12139        for &AdvertisingProcedure
12140    {
12141        #[inline]
12142        unsafe fn encode(
12143            self,
12144            encoder: &mut fidl::encoding::Encoder<'_, D>,
12145            offset: usize,
12146            _depth: fidl::encoding::Depth,
12147        ) -> fidl::Result<()> {
12148            encoder.debug_check_bounds::<AdvertisingProcedure>(offset);
12149            encoder.write_num::<u64>(self.ordinal(), offset);
12150            match self {
12151                AdvertisingProcedure::Legacy(ref val) => {
12152                    fidl::encoding::encode_in_envelope::<Legacy, D>(
12153                        <Legacy as fidl::encoding::ValueTypeMarker>::borrow(val),
12154                        encoder,
12155                        offset + 8,
12156                        _depth,
12157                    )
12158                }
12159                AdvertisingProcedure::Extended(ref val) => {
12160                    fidl::encoding::encode_in_envelope::<Extended, D>(
12161                        <Extended as fidl::encoding::ValueTypeMarker>::borrow(val),
12162                        encoder,
12163                        offset + 8,
12164                        _depth,
12165                    )
12166                }
12167                AdvertisingProcedure::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
12168            }
12169        }
12170    }
12171
12172    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AdvertisingProcedure {
12173        #[inline(always)]
12174        fn new_empty() -> Self {
12175            Self::__SourceBreaking { unknown_ordinal: 0 }
12176        }
12177
12178        #[inline]
12179        unsafe fn decode(
12180            &mut self,
12181            decoder: &mut fidl::encoding::Decoder<'_, D>,
12182            offset: usize,
12183            mut depth: fidl::encoding::Depth,
12184        ) -> fidl::Result<()> {
12185            decoder.debug_check_bounds::<Self>(offset);
12186            #[allow(unused_variables)]
12187            let next_out_of_line = decoder.next_out_of_line();
12188            let handles_before = decoder.remaining_handles();
12189            let (ordinal, inlined, num_bytes, num_handles) =
12190                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
12191
12192            let member_inline_size = match ordinal {
12193                1 => <Legacy as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12194                2 => <Extended as fidl::encoding::TypeMarker>::inline_size(decoder.context),
12195                0 => return Err(fidl::Error::UnknownUnionTag),
12196                _ => num_bytes as usize,
12197            };
12198
12199            if inlined != (member_inline_size <= 4) {
12200                return Err(fidl::Error::InvalidInlineBitInEnvelope);
12201            }
12202            let _inner_offset;
12203            if inlined {
12204                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
12205                _inner_offset = offset + 8;
12206            } else {
12207                depth.increment()?;
12208                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12209            }
12210            match ordinal {
12211                1 => {
12212                    #[allow(irrefutable_let_patterns)]
12213                    if let AdvertisingProcedure::Legacy(_) = self {
12214                        // Do nothing, read the value into the object
12215                    } else {
12216                        // Initialize `self` to the right variant
12217                        *self = AdvertisingProcedure::Legacy(fidl::new_empty!(Legacy, D));
12218                    }
12219                    #[allow(irrefutable_let_patterns)]
12220                    if let AdvertisingProcedure::Legacy(ref mut val) = self {
12221                        fidl::decode!(Legacy, D, val, decoder, _inner_offset, depth)?;
12222                    } else {
12223                        unreachable!()
12224                    }
12225                }
12226                2 => {
12227                    #[allow(irrefutable_let_patterns)]
12228                    if let AdvertisingProcedure::Extended(_) = self {
12229                        // Do nothing, read the value into the object
12230                    } else {
12231                        // Initialize `self` to the right variant
12232                        *self = AdvertisingProcedure::Extended(fidl::new_empty!(Extended, D));
12233                    }
12234                    #[allow(irrefutable_let_patterns)]
12235                    if let AdvertisingProcedure::Extended(ref mut val) = self {
12236                        fidl::decode!(Extended, D, val, decoder, _inner_offset, depth)?;
12237                    } else {
12238                        unreachable!()
12239                    }
12240                }
12241                #[allow(deprecated)]
12242                ordinal => {
12243                    for _ in 0..num_handles {
12244                        decoder.drop_next_handle()?;
12245                    }
12246                    *self = AdvertisingProcedure::__SourceBreaking { unknown_ordinal: ordinal };
12247                }
12248            }
12249            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
12250                return Err(fidl::Error::InvalidNumBytesInEnvelope);
12251            }
12252            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12253                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12254            }
12255            Ok(())
12256        }
12257    }
12258}