fidl_fuchsia_lowpan_device__common/
fidl_fuchsia_lowpan_device__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/// String describing a network type.
12pub type NetworkType = String;
13
14/// Maximum number of channels that can be returned by
15/// [`Device.GetSupportedChannels`].
16///
17/// Value was chosen arbitrarily to be large enough to accommodate any
18/// reasonable future use case.
19pub const MAX_CHANNELS: u16 = 200;
20
21/// Maximum number of distinct network types that a LoWPAN
22/// device can support.
23///
24/// The choice of 16 is an arbitrary upper bound. Most devices will only support one,
25/// and maybe one day a device might support two. Sixteen was chosen because it's
26/// large enough to account for any failure of imagination, yet small enough to not
27/// cause system stability issues.
28pub const MAX_NETWORK_TYPES: u16 = 16;
29
30/// Maximum length of a network type string.
31///
32/// Chosen arbitrarily to be large enough to accommodate any reasonable future
33/// net types.
34pub const MAX_NET_TYPE_LEN: u16 = 64;
35
36/// The maximum number of items that can be returned at one
37/// time by a scan stream.
38pub const MAX_STREAM_SET_SIZE: u16 = 32;
39
40pub const NET_TYPE_RAW_6_LOWPAN: &str = "fuchsia.lowpan.net_type.6lowpan";
41
42pub const NET_TYPE_THREAD_1_X: &str = "org.threadgroup.std.thread.1";
43
44pub const NET_TYPE_UNKNOWN_802_15_4_PID: &str = "fuchsia.lowpan.net_type.802.15.4.pid";
45
46pub const NET_TYPE_ZIGBEE_IP_1_X: &str = "org.zigbee.std.zigbee-ip.1";
47
48/// LoWPAN Connectivity State
49///
50/// This enum describes the level of connectivity being provided
51/// by a device.
52#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
53pub enum ConnectivityState {
54    /// Inactive state.
55    ///
56    /// In this state the device is unprovisioned and administratively
57    /// disabled (inactive).
58    ///
59    /// This state can always be explicitly entered by calling `Leave`
60    /// followed by `SetActive(false)`.
61    Inactive,
62    /// Ready state.
63    ///
64    /// In this state the device is provisioned for a network, but is
65    /// administratively disabled (inactive).
66    ///
67    /// This state can be directly entered with the following actions
68    /// based on the current connectivity state:
69    ///
70    /// * `INACTIVE`: by calling `ProvisionNetwork(...)`.
71    /// * `ATTACHING`, `ATTACHED`, `ISOLATED`, `COMMISSIONING`: by calling `SetActive(false)`.
72    Ready,
73    /// Offline state.
74    ///
75    /// In this state the device is administratively enabled (active)
76    /// but is not provisioned and thus has no network to attach to.
77    ///
78    /// This state can be directly entered with the following actions
79    /// based on the current connectivity state:
80    ///
81    /// * `INACTIVE`: by calling `SetActive(true)`.
82    /// * `ATTACHING`, `ATTACHED`, `ISOLATED`, `COMMISSIONING`: by calling `Leave()`.
83    Offline,
84    /// Attaching state.
85    ///
86    /// In this state the device is administratively enabled
87    /// (active) and either provisioned for a network or shortly
88    /// about to become provisioned for a network.
89    ///
90    /// The interface enters this state when it starts the process
91    /// of trying to find other nodes so that it can attach to any
92    /// pre-existing network fragment, or when it is in the process
93    /// of calculating the optimal values for unspecified parameters
94    /// when forming a new network.
95    ///
96    /// This state can be directly entered with the following actions
97    /// based on the current connectivity state:
98    ///
99    /// * `READY`: by calling `SetActive(true)`
100    /// * `OFFLINE`, `ATTACHING`, `ATTACHED`, `ISOLATED`, `COMMISSIONING`:
101    ///    by calling `ProvisionNetwork(...)`, `FormNetwork(...)`, or `JoinNetwork(...)`
102    Attaching,
103    /// Attached state.
104    ///
105    /// In this state the device is both administratively enabled
106    /// (active) and provisioned for a network. The device is an
107    /// active participant on the network and can communicate with
108    /// peers.
109    ///
110    /// This state usually implies that peers are available, but that
111    /// may not actually be the case due to current network conditions
112    /// or privacy-protecting measures.
113    ///
114    /// This state cannot generally be entered directly, rather
115    /// the device will enter this state automatically from the
116    /// `ATTACHING` or `ISOLATED` states once connectivity has been
117    /// (re)established.
118    Attached,
119    /// Isolated state.
120    ///
121    /// In this state the device is both administratively enabled
122    /// (active) and provisioned for a network. However, the device
123    /// has no connectivity because there are no peers in range on
124    /// the provisioned network.
125    ///
126    /// Once peer devices on the same network come into range
127    /// the connectivity state will eventually switch back to
128    /// `ATTACHED`, indicating restored connectivity with at least
129    /// one peer.
130    ///
131    /// This state cannot generally be entered directly, rather
132    /// the device may enter this state automatically from the
133    /// `ATTACHING` or `ATTACHED` states.
134    Isolated,
135    /// Commissioning state.
136    ///
137    /// Currently unused, but will later be used to
138    /// support in-band commissioning. It is usually appropriate
139    /// to consider this as a synonym for the `ATTACHING` state
140    /// except that the device remains unprovisioned.
141    Commissioning,
142    #[doc(hidden)]
143    __SourceBreaking { unknown_ordinal: i32 },
144}
145
146/// Pattern that matches an unknown `ConnectivityState` member.
147#[macro_export]
148macro_rules! ConnectivityStateUnknown {
149    () => {
150        _
151    };
152}
153
154impl ConnectivityState {
155    #[inline]
156    pub fn from_primitive(prim: i32) -> Option<Self> {
157        match prim {
158            1 => Some(Self::Inactive),
159            2 => Some(Self::Ready),
160            3 => Some(Self::Offline),
161            4 => Some(Self::Attaching),
162            5 => Some(Self::Attached),
163            6 => Some(Self::Isolated),
164            7 => Some(Self::Commissioning),
165            _ => None,
166        }
167    }
168
169    #[inline]
170    pub fn from_primitive_allow_unknown(prim: i32) -> Self {
171        match prim {
172            1 => Self::Inactive,
173            2 => Self::Ready,
174            3 => Self::Offline,
175            4 => Self::Attaching,
176            5 => Self::Attached,
177            6 => Self::Isolated,
178            7 => Self::Commissioning,
179            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
180        }
181    }
182
183    #[inline]
184    pub fn unknown() -> Self {
185        Self::__SourceBreaking { unknown_ordinal: 0x7fffffff }
186    }
187
188    #[inline]
189    pub const fn into_primitive(self) -> i32 {
190        match self {
191            Self::Inactive => 1,
192            Self::Ready => 2,
193            Self::Offline => 3,
194            Self::Attaching => 4,
195            Self::Attached => 5,
196            Self::Isolated => 6,
197            Self::Commissioning => 7,
198            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
199        }
200    }
201
202    #[inline]
203    pub fn is_unknown(&self) -> bool {
204        match self {
205            Self::__SourceBreaking { unknown_ordinal: _ } => true,
206            _ => false,
207        }
208    }
209}
210
211/// LoWPAN Role Type.
212///
213/// This type describes the role a device can assume on a network.
214#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
215pub enum Role {
216    /// Detached role. The interface is not
217    /// currently participating on the network,
218    /// either because it cannot find a parent
219    Detached,
220    /// End-device role. End devices do not route
221    /// traffic on behalf of other nodes.
222    EndDevice,
223    /// Router role. Routers help route traffic
224    /// around the mesh network.
225    ///
226    /// Note that this role is independent of the
227    /// device being a "border router".
228    ///
229    /// Not all network types support this role.
230    Router,
231    /// Sleepy End-Device role.
232    ///
233    /// End devices with this role are nominally asleep,
234    /// waking up periodically to check in with their
235    /// parent to see if there are packets destined for
236    /// them. Such devices are capable of extraordinarily
237    /// low power consumption, but packet latency can be
238    /// on the order of dozens of seconds(depending on how
239    /// the node is configured). Not all network types
240    /// support this role.
241    ///
242    /// Not all network types support this role.
243    SleepyEndDevice,
244    /// Sleepy-router role.
245    ///
246    /// Routers with this role are nominally asleep,
247    /// waking up periodically to check in with
248    /// other routers and their children.
249    ///
250    /// Not all network types support this role.
251    SleepyRouter,
252    /// Leader role.
253    ///
254    /// On Thread networks, for each partition/fragment
255    /// one router is designated as the "leader", which
256    /// means that it is considered authoritative for
257    /// all network data. In most cases this role can be
258    /// considered as a synonym to Role::ROUTER.
259    ///
260    /// Not all network types support this role.
261    Leader,
262    /// Coordinator role.
263    ///
264    /// Not all network types support this role.
265    Coordinator,
266    #[doc(hidden)]
267    __SourceBreaking { unknown_ordinal: i32 },
268}
269
270/// Pattern that matches an unknown `Role` member.
271#[macro_export]
272macro_rules! RoleUnknown {
273    () => {
274        _
275    };
276}
277
278impl Role {
279    #[inline]
280    pub fn from_primitive(prim: i32) -> Option<Self> {
281        match prim {
282            1 => Some(Self::Detached),
283            2 => Some(Self::EndDevice),
284            3 => Some(Self::Router),
285            4 => Some(Self::SleepyEndDevice),
286            5 => Some(Self::SleepyRouter),
287            6 => Some(Self::Leader),
288            7 => Some(Self::Coordinator),
289            _ => None,
290        }
291    }
292
293    #[inline]
294    pub fn from_primitive_allow_unknown(prim: i32) -> Self {
295        match prim {
296            1 => Self::Detached,
297            2 => Self::EndDevice,
298            3 => Self::Router,
299            4 => Self::SleepyEndDevice,
300            5 => Self::SleepyRouter,
301            6 => Self::Leader,
302            7 => Self::Coordinator,
303            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
304        }
305    }
306
307    #[inline]
308    pub fn unknown() -> Self {
309        Self::__SourceBreaking { unknown_ordinal: 0x7fffffff }
310    }
311
312    #[inline]
313    pub const fn into_primitive(self) -> i32 {
314        match self {
315            Self::Detached => 1,
316            Self::EndDevice => 2,
317            Self::Router => 3,
318            Self::SleepyEndDevice => 4,
319            Self::SleepyRouter => 5,
320            Self::Leader => 6,
321            Self::Coordinator => 7,
322            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
323        }
324    }
325
326    #[inline]
327    pub fn is_unknown(&self) -> bool {
328        match self {
329            Self::__SourceBreaking { unknown_ordinal: _ } => true,
330            _ => false,
331        }
332    }
333}
334
335#[derive(Clone, Debug, PartialEq)]
336pub struct CountersGetResponse {
337    pub counters: AllCounters,
338}
339
340impl fidl::Persistable for CountersGetResponse {}
341
342#[derive(Clone, Debug, PartialEq)]
343pub struct CountersResetResponse {
344    pub counters: AllCounters,
345}
346
347impl fidl::Persistable for CountersResetResponse {}
348
349#[derive(Clone, Debug, PartialEq)]
350pub struct DeviceExtraGetCredentialResponse {
351    pub credential: Option<Box<Credential>>,
352}
353
354impl fidl::Persistable for DeviceExtraGetCredentialResponse {}
355
356#[derive(Clone, Debug, PartialEq)]
357pub struct DeviceExtraGetCurrentMacAddressResponse {
358    pub address: fidl_fuchsia_lowpan__common::MacAddress,
359}
360
361impl fidl::Persistable for DeviceExtraGetCurrentMacAddressResponse {}
362
363#[derive(Clone, Debug, PartialEq)]
364pub struct DeviceExtraWatchIdentityResponse {
365    pub identity: Identity,
366}
367
368impl fidl::Persistable for DeviceExtraWatchIdentityResponse {}
369
370#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
371pub struct DeviceGetSupportedNetworkTypesResponse {
372    pub network_types: Vec<String>,
373}
374
375impl fidl::Persistable for DeviceGetSupportedNetworkTypesResponse {}
376
377#[derive(Clone, Debug, PartialEq)]
378pub struct DeviceProvisionNetworkRequest {
379    pub params: ProvisioningParams,
380}
381
382impl fidl::Persistable for DeviceProvisionNetworkRequest {}
383
384#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
385pub struct DeviceSetActiveRequest {
386    pub active: bool,
387}
388
389impl fidl::Persistable for DeviceSetActiveRequest {}
390
391#[derive(Clone, Debug, PartialEq)]
392pub struct DeviceWatchDeviceStateResponse {
393    pub device_combined_state: DeviceState,
394}
395
396impl fidl::Persistable for DeviceWatchDeviceStateResponse {}
397
398#[derive(Clone, Debug, PartialEq)]
399pub struct EnergyScanResultStreamNextResponse {
400    pub results: Vec<EnergyScanResult>,
401}
402
403impl fidl::Persistable for EnergyScanResultStreamNextResponse {}
404
405#[derive(Clone, Debug, PartialEq)]
406pub struct ProvisioningParams {
407    /// The identity of the network.
408    pub identity: Identity,
409    /// The credential used to authenticate to
410    /// the network.
411    pub credential: Option<Box<Credential>>,
412}
413
414impl fidl::Persistable for ProvisioningParams {}
415
416/// Describes all counters.
417///
418/// May be empty if no counters are supported.
419#[derive(Clone, Debug, Default, PartialEq)]
420pub struct AllCounters {
421    /// MAC Counters for TX
422    pub mac_tx: Option<MacCounters>,
423    /// MAC Counters for RX
424    pub mac_rx: Option<MacCounters>,
425    /// Coex Counters for TX
426    pub coex_tx: Option<CoexCounters>,
427    /// Coex Counters for RX
428    pub coex_rx: Option<CoexCounters>,
429    /// Coex stats may be incorrect due to internal counter overflow.
430    ///
431    /// Reset the counters to clear this flag.
432    pub coex_saturated: Option<bool>,
433    /// IP Counters for TX.
434    pub ip_tx: Option<IpCounters>,
435    /// IP Counters for RX.
436    pub ip_rx: Option<IpCounters>,
437    #[doc(hidden)]
438    pub __source_breaking: fidl::marker::SourceBreaking,
439}
440
441impl fidl::Persistable for AllCounters {}
442
443/// Counters associated with RF Coexistance.
444///
445/// Some counters are only valid for RX or TX. See [this][1] for more info.
446///
447/// [1]: https://github.com/openthread/wpantund/blob/4ae4619/third_party/openthread/src/ncp/spinel.h#L1738-L1775
448#[derive(Clone, Debug, Default, PartialEq)]
449pub struct CoexCounters {
450    /// The number of requests
451    pub requests: Option<u64>,
452    /// The number of requests while grant was active
453    pub grant_immediate: Option<u64>,
454    /// The number of requests while grant was inactive
455    pub grant_wait: Option<u64>,
456    /// The number of requests while grant was inactive that were
457    /// ultimately granted
458    pub grant_wait_activated: Option<u64>,
459    /// The number of requests while grant was inactive that timed out
460    pub grant_wait_timeout: Option<u64>,
461    /// The number of requests that were in progress when grant was
462    /// deactivated
463    pub grant_deactivated_during_request: Option<u64>,
464    /// The number of requests that were not granted within 50µs
465    pub delayed_grant: Option<u64>,
466    /// The average time in µsec from request to grant
467    pub avg_delay_request_to_grant_usec: Option<u32>,
468    /// The number of requests that completed without receiving grant.
469    ///
470    /// Receive only.
471    pub grant_none: Option<u64>,
472    #[doc(hidden)]
473    pub __source_breaking: fidl::marker::SourceBreaking,
474}
475
476impl fidl::Persistable for CoexCounters {}
477
478/// Combined State for LoWPAN Devices
479///
480/// Contains the various properties of a LoWPAN device
481/// that define its current operational state.
482///
483/// You will get a snapshot of the current state upon the first
484/// invocation of `WatchDeviceState()`, after which future
485/// invocations of that method will return deltas.
486#[derive(Clone, Debug, Default, PartialEq)]
487pub struct DeviceState {
488    /// LoWPAN Connectivity State
489    ///
490    /// This field describes the current level of connectivity being
491    /// provided by this device.
492    pub connectivity_state: Option<ConnectivityState>,
493    /// LoWPAN Role
494    ///
495    /// This field describes the current role this device is taking
496    /// on the current network.
497    pub role: Option<Role>,
498    #[doc(hidden)]
499    pub __source_breaking: fidl::marker::SourceBreaking,
500}
501
502impl fidl::Persistable for DeviceState {}
503
504/// Describes the parameters of an energy scan.
505#[derive(Clone, Debug, Default, PartialEq)]
506pub struct EnergyScanParameters {
507    /// Subset of channels to scan.
508    ///
509    /// If unspecified, all channels will be scanned.
510    pub channels: Option<Vec<u16>>,
511    /// Desired dwell time per-channel for the energy scan,
512    /// measured in milliseconds.
513    ///
514    /// Note that firmware limitations may prevent the
515    /// exact dwell time from being used. In such cases
516    /// an approximation will be used.
517    ///
518    /// Implementations must be able to support dwell times of at least
519    /// 5000ms (5 seconds). The exact supported dwell-time range is
520    /// device/driver dependent.
521    ///
522    /// Setting a value outside of the supported range of
523    /// values for this device will result in the value being
524    /// clamped to the closest valid value, so setting a value of zero
525    /// will always request the smallest energy scan duration the
526    /// device is capable of.
527    ///
528    /// If unspecified, a dwell time of approximately 500ms will be used.
529    pub dwell_time_ms: Option<u32>,
530    #[doc(hidden)]
531    pub __source_breaking: fidl::marker::SourceBreaking,
532}
533
534impl fidl::Persistable for EnergyScanParameters {}
535
536/// Describes the result from one channel of an energy scan.
537#[derive(Clone, Debug, Default, PartialEq)]
538pub struct EnergyScanResult {
539    /// The channel index for this energy scan result.
540    pub channel_index: Option<u16>,
541    /// The maximum RSSI detected on this channel.
542    pub max_rssi: Option<i32>,
543    /// The minimum RSSI detected on this channel.
544    pub min_rssi: Option<i32>,
545    #[doc(hidden)]
546    pub __source_breaking: fidl::marker::SourceBreaking,
547}
548
549impl fidl::Persistable for EnergyScanResult {}
550
551#[derive(Clone, Debug, Default, PartialEq)]
552pub struct Identity {
553    /// The raw bytes for the network name.
554    /// This is typically a [StringPrep'd][1] UTF8 encoding.
555    ///
556    /// Note that extra care must be taken when displaying
557    /// this value to users, since there are many ways
558    /// to make visually similar UTF8 strings that
559    /// have differing bytecode representations.
560    ///
561    /// [1]: https://tools.ietf.org/html/rfc3454
562    pub raw_name: Option<Vec<u8>>,
563    /// String identifying the type of network.
564    ///
565    /// Well-known protocol ids are associated with
566    /// specific string values (like "org.threadgroup.std.thread"
567    /// or "org.zigbee.std.zigbee-ip"). For unknown protocol ids,
568    /// the string will map to something like
569    /// `fuchsia.lowpan.net_type.802.15.4.pid.XX`, where `XX` is
570    /// the value of the protocol id from a 802.14.5 beacon.
571    /// This field is optional when joining, forming, or provisioning.
572    pub net_type: Option<String>,
573    /// Channel Index.
574    pub channel: Option<u16>,
575    /// PANID for 802.14.5-based networks (or the equivalent).
576    pub panid: Option<u16>,
577    /// IPv6 Mesh-local prefix.
578    ///
579    /// This parameter allows you to determine the mesh-local
580    /// IPv6 prefix for the current network, or to specify one
581    /// when provisioning the interface for a network or forming
582    /// a new network.
583    ///
584    /// The prefix length is always 64 bits, so only the upper
585    /// 64 bits of the value are used: the least significant bits
586    /// must be ignored when read and zero when set.
587    ///
588    /// This field is ignored when supplied to `JoinNetwork()`.
589    pub mesh_local_prefix: Option<fidl_fuchsia_net__common::Ipv6AddressWithPrefix>,
590    /// Extended PANID.
591    pub xpanid: Option<[u8; 8]>,
592    #[doc(hidden)]
593    pub __source_breaking: fidl::marker::SourceBreaking,
594}
595
596impl fidl::Persistable for Identity {}
597
598/// Counters associated with the IP layer.
599#[derive(Clone, Debug, Default, PartialEq)]
600pub struct IpCounters {
601    /// The number of IPv6 packets successfully transmitted/received.
602    pub success: Option<u32>,
603    /// The number of IPv6 packets failed to transmit/receive.
604    pub failure: Option<u32>,
605    #[doc(hidden)]
606    pub __source_breaking: fidl::marker::SourceBreaking,
607}
608
609impl fidl::Persistable for IpCounters {}
610
611/// Counters associated with the MAC layer.
612///
613/// Some counters are only valid for RX or TX.
614#[derive(Clone, Debug, Default, PartialEq)]
615pub struct MacCounters {
616    /// The total number of frames
617    pub total: Option<u32>,
618    /// The total number of unicast frames
619    pub unicast: Option<u32>,
620    /// The total number of broadcast frames
621    pub broadcast: Option<u32>,
622    /// The number of frames with ack request
623    pub ack_requested: Option<u32>,
624    /// The number of frames that were acked
625    pub acked: Option<u32>,
626    /// The number of frames without ack request
627    pub no_ack_requested: Option<u32>,
628    /// The number of data frames
629    pub data: Option<u32>,
630    /// The number of data poll frames
631    pub data_poll: Option<u32>,
632    /// The number of beacon frames
633    pub beacon: Option<u32>,
634    /// The number of beacon request frames
635    pub beacon_request: Option<u32>,
636    /// The number of other types of frames
637    pub other: Option<u32>,
638    /// The number of frames filtered by address filter (allowlist
639    /// or denylist).
640    pub address_filtered: Option<u32>,
641    /// The number of retransmission attempts.
642    /// TX only.
643    pub retries: Option<u32>,
644    /// The number of expired retransmission retries for direct message.
645    /// TX only.
646    pub direct_max_retry_expiry: Option<u32>,
647    /// The number of expired retransmission retries for indirect message
648    /// TX only.
649    pub indirect_max_retry_expiry: Option<u32>,
650    /// The number of received frames filtered by destination check.
651    /// RX only.
652    pub dest_addr_filtered: Option<u32>,
653    /// The number of received duplicated frames.
654    /// RX only.
655    pub duplicated: Option<u32>,
656    /// The number of received frames with no or malformed content.
657    /// RX only.
658    pub err_no_frame: Option<u32>,
659    /// The number of received frames from unknown neighbor.
660    /// RX only.
661    pub err_unknown_neighbor: Option<u32>,
662    /// The number of received frames whose source address is invalid.
663    /// RX only.
664    pub err_invalid_src_addr: Option<u32>,
665    /// The number of received frames with security error.
666    /// RX only.
667    pub err_sec: Option<u32>,
668    /// The number of received frames with FCS error.
669    /// RX only.
670    pub err_fcs: Option<u32>,
671    /// The number of CCA failures.
672    /// TX only.
673    pub err_cca: Option<u32>,
674    /// The number of frame transmission failures due to abort error.
675    /// TX only.
676    pub err_abort: Option<u32>,
677    /// The number of frames that were dropped due to a busy channel.
678    /// TX only.
679    pub err_busy_channel: Option<u32>,
680    /// The number of frames that encountered some other error.
681    pub err_other: Option<u32>,
682    #[doc(hidden)]
683    pub __source_breaking: fidl::marker::SourceBreaking,
684}
685
686impl fidl::Persistable for MacCounters {}
687
688/// Describes a LoWPAN credential.
689///
690/// Currently only supports a symmetric network key,
691/// but may be extended in the future to support other
692/// types of credentials, such as passwords, PAKE
693/// secrets, or a reference to a certificate/private-key
694/// pair.
695#[derive(Clone, Debug)]
696pub enum Credential {
697    /// Describes a symmetric key credential.
698    ///
699    /// The size of the symmetric key is defined by the
700    /// underlying network technology. For Thread this
701    /// is a 16-byte value.
702    ///
703    /// Note that this value is not a password.
704    NetworkKey(Vec<u8>),
705    #[doc(hidden)]
706    __SourceBreaking { unknown_ordinal: u64 },
707}
708
709/// Pattern that matches an unknown `Credential` member.
710#[macro_export]
711macro_rules! CredentialUnknown {
712    () => {
713        _
714    };
715}
716
717// Custom PartialEq so that unknown variants are not equal to themselves.
718impl PartialEq for Credential {
719    fn eq(&self, other: &Self) -> bool {
720        match (self, other) {
721            (Self::NetworkKey(x), Self::NetworkKey(y)) => *x == *y,
722            _ => false,
723        }
724    }
725}
726
727impl Credential {
728    #[inline]
729    pub fn ordinal(&self) -> u64 {
730        match *self {
731            Self::NetworkKey(_) => 1,
732            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
733        }
734    }
735
736    #[inline]
737    pub fn unknown_variant_for_testing() -> Self {
738        Self::__SourceBreaking { unknown_ordinal: 0 }
739    }
740
741    #[inline]
742    pub fn is_unknown(&self) -> bool {
743        match self {
744            Self::__SourceBreaking { .. } => true,
745            _ => false,
746        }
747    }
748}
749
750impl fidl::Persistable for Credential {}
751
752pub mod counters_ordinals {
753    pub const GET: u64 = 0xaa28d44c1535a24;
754    pub const RESET: u64 = 0x4cf9a102017cf7ad;
755}
756
757pub mod counters_connector_ordinals {
758    pub const CONNECT: u64 = 0x61ec847f2702d188;
759}
760
761pub mod device_ordinals {
762    pub const PROVISION_NETWORK: u64 = 0x3501046988e17076;
763    pub const LEAVE_NETWORK: u64 = 0x66919e4f9752c53e;
764    pub const SET_ACTIVE: u64 = 0x55a6837f8bbb344b;
765    pub const GET_SUPPORTED_NETWORK_TYPES: u64 = 0x6d8f71a5beb15ebf;
766    pub const WATCH_DEVICE_STATE: u64 = 0x593be5b83e80d249;
767}
768
769pub mod device_connector_ordinals {
770    pub const CONNECT: u64 = 0x63470c4c0c8e678a;
771}
772
773pub mod device_extra_ordinals {
774    pub const GET_CREDENTIAL: u64 = 0x77f75f289c8c4ceb;
775    pub const WATCH_IDENTITY: u64 = 0xb9f5d8963eaebc6;
776    pub const GET_CURRENT_MAC_ADDRESS: u64 = 0x70835954071d94dd;
777}
778
779pub mod device_extra_connector_ordinals {
780    pub const CONNECT: u64 = 0x2959be873ae18ae3;
781}
782
783pub mod energy_scan_ordinals {
784    pub const START_ENERGY_SCAN: u64 = 0x4b2928a05c619b06;
785}
786
787pub mod energy_scan_connector_ordinals {
788    pub const CONNECT: u64 = 0x1076a774e74ab290;
789}
790
791pub mod energy_scan_result_stream_ordinals {
792    pub const NEXT: u64 = 0x7f0139fc06fd6a9e;
793}
794
795mod internal {
796    use super::*;
797    unsafe impl fidl::encoding::TypeMarker for ConnectivityState {
798        type Owned = Self;
799
800        #[inline(always)]
801        fn inline_align(_context: fidl::encoding::Context) -> usize {
802            std::mem::align_of::<i32>()
803        }
804
805        #[inline(always)]
806        fn inline_size(_context: fidl::encoding::Context) -> usize {
807            std::mem::size_of::<i32>()
808        }
809
810        #[inline(always)]
811        fn encode_is_copy() -> bool {
812            false
813        }
814
815        #[inline(always)]
816        fn decode_is_copy() -> bool {
817            false
818        }
819    }
820
821    impl fidl::encoding::ValueTypeMarker for ConnectivityState {
822        type Borrowed<'a> = Self;
823        #[inline(always)]
824        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
825            *value
826        }
827    }
828
829    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
830        for ConnectivityState
831    {
832        #[inline]
833        unsafe fn encode(
834            self,
835            encoder: &mut fidl::encoding::Encoder<'_, D>,
836            offset: usize,
837            _depth: fidl::encoding::Depth,
838        ) -> fidl::Result<()> {
839            encoder.debug_check_bounds::<Self>(offset);
840            encoder.write_num(self.into_primitive(), offset);
841            Ok(())
842        }
843    }
844
845    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectivityState {
846        #[inline(always)]
847        fn new_empty() -> Self {
848            Self::unknown()
849        }
850
851        #[inline]
852        unsafe fn decode(
853            &mut self,
854            decoder: &mut fidl::encoding::Decoder<'_, D>,
855            offset: usize,
856            _depth: fidl::encoding::Depth,
857        ) -> fidl::Result<()> {
858            decoder.debug_check_bounds::<Self>(offset);
859            let prim = decoder.read_num::<i32>(offset);
860
861            *self = Self::from_primitive_allow_unknown(prim);
862            Ok(())
863        }
864    }
865    unsafe impl fidl::encoding::TypeMarker for Role {
866        type Owned = Self;
867
868        #[inline(always)]
869        fn inline_align(_context: fidl::encoding::Context) -> usize {
870            std::mem::align_of::<i32>()
871        }
872
873        #[inline(always)]
874        fn inline_size(_context: fidl::encoding::Context) -> usize {
875            std::mem::size_of::<i32>()
876        }
877
878        #[inline(always)]
879        fn encode_is_copy() -> bool {
880            false
881        }
882
883        #[inline(always)]
884        fn decode_is_copy() -> bool {
885            false
886        }
887    }
888
889    impl fidl::encoding::ValueTypeMarker for Role {
890        type Borrowed<'a> = Self;
891        #[inline(always)]
892        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
893            *value
894        }
895    }
896
897    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Role {
898        #[inline]
899        unsafe fn encode(
900            self,
901            encoder: &mut fidl::encoding::Encoder<'_, D>,
902            offset: usize,
903            _depth: fidl::encoding::Depth,
904        ) -> fidl::Result<()> {
905            encoder.debug_check_bounds::<Self>(offset);
906            encoder.write_num(self.into_primitive(), offset);
907            Ok(())
908        }
909    }
910
911    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Role {
912        #[inline(always)]
913        fn new_empty() -> Self {
914            Self::unknown()
915        }
916
917        #[inline]
918        unsafe fn decode(
919            &mut self,
920            decoder: &mut fidl::encoding::Decoder<'_, D>,
921            offset: usize,
922            _depth: fidl::encoding::Depth,
923        ) -> fidl::Result<()> {
924            decoder.debug_check_bounds::<Self>(offset);
925            let prim = decoder.read_num::<i32>(offset);
926
927            *self = Self::from_primitive_allow_unknown(prim);
928            Ok(())
929        }
930    }
931
932    impl fidl::encoding::ValueTypeMarker for CountersGetResponse {
933        type Borrowed<'a> = &'a Self;
934        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
935            value
936        }
937    }
938
939    unsafe impl fidl::encoding::TypeMarker for CountersGetResponse {
940        type Owned = Self;
941
942        #[inline(always)]
943        fn inline_align(_context: fidl::encoding::Context) -> usize {
944            8
945        }
946
947        #[inline(always)]
948        fn inline_size(_context: fidl::encoding::Context) -> usize {
949            16
950        }
951    }
952
953    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CountersGetResponse, D>
954        for &CountersGetResponse
955    {
956        #[inline]
957        unsafe fn encode(
958            self,
959            encoder: &mut fidl::encoding::Encoder<'_, D>,
960            offset: usize,
961            _depth: fidl::encoding::Depth,
962        ) -> fidl::Result<()> {
963            encoder.debug_check_bounds::<CountersGetResponse>(offset);
964            // Delegate to tuple encoding.
965            fidl::encoding::Encode::<CountersGetResponse, D>::encode(
966                (<AllCounters as fidl::encoding::ValueTypeMarker>::borrow(&self.counters),),
967                encoder,
968                offset,
969                _depth,
970            )
971        }
972    }
973    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AllCounters, D>>
974        fidl::encoding::Encode<CountersGetResponse, D> for (T0,)
975    {
976        #[inline]
977        unsafe fn encode(
978            self,
979            encoder: &mut fidl::encoding::Encoder<'_, D>,
980            offset: usize,
981            depth: fidl::encoding::Depth,
982        ) -> fidl::Result<()> {
983            encoder.debug_check_bounds::<CountersGetResponse>(offset);
984            // Zero out padding regions. There's no need to apply masks
985            // because the unmasked parts will be overwritten by fields.
986            // Write the fields.
987            self.0.encode(encoder, offset + 0, depth)?;
988            Ok(())
989        }
990    }
991
992    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CountersGetResponse {
993        #[inline(always)]
994        fn new_empty() -> Self {
995            Self { counters: fidl::new_empty!(AllCounters, D) }
996        }
997
998        #[inline]
999        unsafe fn decode(
1000            &mut self,
1001            decoder: &mut fidl::encoding::Decoder<'_, D>,
1002            offset: usize,
1003            _depth: fidl::encoding::Depth,
1004        ) -> fidl::Result<()> {
1005            decoder.debug_check_bounds::<Self>(offset);
1006            // Verify that padding bytes are zero.
1007            fidl::decode!(AllCounters, D, &mut self.counters, decoder, offset + 0, _depth)?;
1008            Ok(())
1009        }
1010    }
1011
1012    impl fidl::encoding::ValueTypeMarker for CountersResetResponse {
1013        type Borrowed<'a> = &'a Self;
1014        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1015            value
1016        }
1017    }
1018
1019    unsafe impl fidl::encoding::TypeMarker for CountersResetResponse {
1020        type Owned = Self;
1021
1022        #[inline(always)]
1023        fn inline_align(_context: fidl::encoding::Context) -> usize {
1024            8
1025        }
1026
1027        #[inline(always)]
1028        fn inline_size(_context: fidl::encoding::Context) -> usize {
1029            16
1030        }
1031    }
1032
1033    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CountersResetResponse, D>
1034        for &CountersResetResponse
1035    {
1036        #[inline]
1037        unsafe fn encode(
1038            self,
1039            encoder: &mut fidl::encoding::Encoder<'_, D>,
1040            offset: usize,
1041            _depth: fidl::encoding::Depth,
1042        ) -> fidl::Result<()> {
1043            encoder.debug_check_bounds::<CountersResetResponse>(offset);
1044            // Delegate to tuple encoding.
1045            fidl::encoding::Encode::<CountersResetResponse, D>::encode(
1046                (<AllCounters as fidl::encoding::ValueTypeMarker>::borrow(&self.counters),),
1047                encoder,
1048                offset,
1049                _depth,
1050            )
1051        }
1052    }
1053    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AllCounters, D>>
1054        fidl::encoding::Encode<CountersResetResponse, D> for (T0,)
1055    {
1056        #[inline]
1057        unsafe fn encode(
1058            self,
1059            encoder: &mut fidl::encoding::Encoder<'_, D>,
1060            offset: usize,
1061            depth: fidl::encoding::Depth,
1062        ) -> fidl::Result<()> {
1063            encoder.debug_check_bounds::<CountersResetResponse>(offset);
1064            // Zero out padding regions. There's no need to apply masks
1065            // because the unmasked parts will be overwritten by fields.
1066            // Write the fields.
1067            self.0.encode(encoder, offset + 0, depth)?;
1068            Ok(())
1069        }
1070    }
1071
1072    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CountersResetResponse {
1073        #[inline(always)]
1074        fn new_empty() -> Self {
1075            Self { counters: fidl::new_empty!(AllCounters, D) }
1076        }
1077
1078        #[inline]
1079        unsafe fn decode(
1080            &mut self,
1081            decoder: &mut fidl::encoding::Decoder<'_, D>,
1082            offset: usize,
1083            _depth: fidl::encoding::Depth,
1084        ) -> fidl::Result<()> {
1085            decoder.debug_check_bounds::<Self>(offset);
1086            // Verify that padding bytes are zero.
1087            fidl::decode!(AllCounters, D, &mut self.counters, decoder, offset + 0, _depth)?;
1088            Ok(())
1089        }
1090    }
1091
1092    impl fidl::encoding::ValueTypeMarker for DeviceExtraGetCredentialResponse {
1093        type Borrowed<'a> = &'a Self;
1094        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1095            value
1096        }
1097    }
1098
1099    unsafe impl fidl::encoding::TypeMarker for DeviceExtraGetCredentialResponse {
1100        type Owned = Self;
1101
1102        #[inline(always)]
1103        fn inline_align(_context: fidl::encoding::Context) -> usize {
1104            8
1105        }
1106
1107        #[inline(always)]
1108        fn inline_size(_context: fidl::encoding::Context) -> usize {
1109            16
1110        }
1111    }
1112
1113    unsafe impl<D: fidl::encoding::ResourceDialect>
1114        fidl::encoding::Encode<DeviceExtraGetCredentialResponse, D>
1115        for &DeviceExtraGetCredentialResponse
1116    {
1117        #[inline]
1118        unsafe fn encode(
1119            self,
1120            encoder: &mut fidl::encoding::Encoder<'_, D>,
1121            offset: usize,
1122            _depth: fidl::encoding::Depth,
1123        ) -> fidl::Result<()> {
1124            encoder.debug_check_bounds::<DeviceExtraGetCredentialResponse>(offset);
1125            // Delegate to tuple encoding.
1126            fidl::encoding::Encode::<DeviceExtraGetCredentialResponse, D>::encode(
1127                (
1128                    <fidl::encoding::OptionalUnion<Credential> as fidl::encoding::ValueTypeMarker>::borrow(&self.credential),
1129                ),
1130                encoder, offset, _depth
1131            )
1132        }
1133    }
1134    unsafe impl<
1135            D: fidl::encoding::ResourceDialect,
1136            T0: fidl::encoding::Encode<fidl::encoding::OptionalUnion<Credential>, D>,
1137        > fidl::encoding::Encode<DeviceExtraGetCredentialResponse, D> for (T0,)
1138    {
1139        #[inline]
1140        unsafe fn encode(
1141            self,
1142            encoder: &mut fidl::encoding::Encoder<'_, D>,
1143            offset: usize,
1144            depth: fidl::encoding::Depth,
1145        ) -> fidl::Result<()> {
1146            encoder.debug_check_bounds::<DeviceExtraGetCredentialResponse>(offset);
1147            // Zero out padding regions. There's no need to apply masks
1148            // because the unmasked parts will be overwritten by fields.
1149            // Write the fields.
1150            self.0.encode(encoder, offset + 0, depth)?;
1151            Ok(())
1152        }
1153    }
1154
1155    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1156        for DeviceExtraGetCredentialResponse
1157    {
1158        #[inline(always)]
1159        fn new_empty() -> Self {
1160            Self { credential: fidl::new_empty!(fidl::encoding::OptionalUnion<Credential>, D) }
1161        }
1162
1163        #[inline]
1164        unsafe fn decode(
1165            &mut self,
1166            decoder: &mut fidl::encoding::Decoder<'_, D>,
1167            offset: usize,
1168            _depth: fidl::encoding::Depth,
1169        ) -> fidl::Result<()> {
1170            decoder.debug_check_bounds::<Self>(offset);
1171            // Verify that padding bytes are zero.
1172            fidl::decode!(
1173                fidl::encoding::OptionalUnion<Credential>,
1174                D,
1175                &mut self.credential,
1176                decoder,
1177                offset + 0,
1178                _depth
1179            )?;
1180            Ok(())
1181        }
1182    }
1183
1184    impl fidl::encoding::ValueTypeMarker for DeviceExtraGetCurrentMacAddressResponse {
1185        type Borrowed<'a> = &'a Self;
1186        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1187            value
1188        }
1189    }
1190
1191    unsafe impl fidl::encoding::TypeMarker for DeviceExtraGetCurrentMacAddressResponse {
1192        type Owned = Self;
1193
1194        #[inline(always)]
1195        fn inline_align(_context: fidl::encoding::Context) -> usize {
1196            1
1197        }
1198
1199        #[inline(always)]
1200        fn inline_size(_context: fidl::encoding::Context) -> usize {
1201            8
1202        }
1203    }
1204
1205    unsafe impl<D: fidl::encoding::ResourceDialect>
1206        fidl::encoding::Encode<DeviceExtraGetCurrentMacAddressResponse, D>
1207        for &DeviceExtraGetCurrentMacAddressResponse
1208    {
1209        #[inline]
1210        unsafe fn encode(
1211            self,
1212            encoder: &mut fidl::encoding::Encoder<'_, D>,
1213            offset: usize,
1214            _depth: fidl::encoding::Depth,
1215        ) -> fidl::Result<()> {
1216            encoder.debug_check_bounds::<DeviceExtraGetCurrentMacAddressResponse>(offset);
1217            // Delegate to tuple encoding.
1218            fidl::encoding::Encode::<DeviceExtraGetCurrentMacAddressResponse, D>::encode(
1219                (
1220                    <fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
1221                ),
1222                encoder, offset, _depth
1223            )
1224        }
1225    }
1226    unsafe impl<
1227            D: fidl::encoding::ResourceDialect,
1228            T0: fidl::encoding::Encode<fidl_fuchsia_lowpan__common::MacAddress, D>,
1229        > fidl::encoding::Encode<DeviceExtraGetCurrentMacAddressResponse, D> for (T0,)
1230    {
1231        #[inline]
1232        unsafe fn encode(
1233            self,
1234            encoder: &mut fidl::encoding::Encoder<'_, D>,
1235            offset: usize,
1236            depth: fidl::encoding::Depth,
1237        ) -> fidl::Result<()> {
1238            encoder.debug_check_bounds::<DeviceExtraGetCurrentMacAddressResponse>(offset);
1239            // Zero out padding regions. There's no need to apply masks
1240            // because the unmasked parts will be overwritten by fields.
1241            // Write the fields.
1242            self.0.encode(encoder, offset + 0, depth)?;
1243            Ok(())
1244        }
1245    }
1246
1247    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1248        for DeviceExtraGetCurrentMacAddressResponse
1249    {
1250        #[inline(always)]
1251        fn new_empty() -> Self {
1252            Self { address: fidl::new_empty!(fidl_fuchsia_lowpan__common::MacAddress, D) }
1253        }
1254
1255        #[inline]
1256        unsafe fn decode(
1257            &mut self,
1258            decoder: &mut fidl::encoding::Decoder<'_, D>,
1259            offset: usize,
1260            _depth: fidl::encoding::Depth,
1261        ) -> fidl::Result<()> {
1262            decoder.debug_check_bounds::<Self>(offset);
1263            // Verify that padding bytes are zero.
1264            fidl::decode!(
1265                fidl_fuchsia_lowpan__common::MacAddress,
1266                D,
1267                &mut self.address,
1268                decoder,
1269                offset + 0,
1270                _depth
1271            )?;
1272            Ok(())
1273        }
1274    }
1275
1276    impl fidl::encoding::ValueTypeMarker for DeviceExtraWatchIdentityResponse {
1277        type Borrowed<'a> = &'a Self;
1278        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1279            value
1280        }
1281    }
1282
1283    unsafe impl fidl::encoding::TypeMarker for DeviceExtraWatchIdentityResponse {
1284        type Owned = Self;
1285
1286        #[inline(always)]
1287        fn inline_align(_context: fidl::encoding::Context) -> usize {
1288            8
1289        }
1290
1291        #[inline(always)]
1292        fn inline_size(_context: fidl::encoding::Context) -> usize {
1293            16
1294        }
1295    }
1296
1297    unsafe impl<D: fidl::encoding::ResourceDialect>
1298        fidl::encoding::Encode<DeviceExtraWatchIdentityResponse, D>
1299        for &DeviceExtraWatchIdentityResponse
1300    {
1301        #[inline]
1302        unsafe fn encode(
1303            self,
1304            encoder: &mut fidl::encoding::Encoder<'_, D>,
1305            offset: usize,
1306            _depth: fidl::encoding::Depth,
1307        ) -> fidl::Result<()> {
1308            encoder.debug_check_bounds::<DeviceExtraWatchIdentityResponse>(offset);
1309            // Delegate to tuple encoding.
1310            fidl::encoding::Encode::<DeviceExtraWatchIdentityResponse, D>::encode(
1311                (<Identity as fidl::encoding::ValueTypeMarker>::borrow(&self.identity),),
1312                encoder,
1313                offset,
1314                _depth,
1315            )
1316        }
1317    }
1318    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Identity, D>>
1319        fidl::encoding::Encode<DeviceExtraWatchIdentityResponse, D> for (T0,)
1320    {
1321        #[inline]
1322        unsafe fn encode(
1323            self,
1324            encoder: &mut fidl::encoding::Encoder<'_, D>,
1325            offset: usize,
1326            depth: fidl::encoding::Depth,
1327        ) -> fidl::Result<()> {
1328            encoder.debug_check_bounds::<DeviceExtraWatchIdentityResponse>(offset);
1329            // Zero out padding regions. There's no need to apply masks
1330            // because the unmasked parts will be overwritten by fields.
1331            // Write the fields.
1332            self.0.encode(encoder, offset + 0, depth)?;
1333            Ok(())
1334        }
1335    }
1336
1337    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1338        for DeviceExtraWatchIdentityResponse
1339    {
1340        #[inline(always)]
1341        fn new_empty() -> Self {
1342            Self { identity: fidl::new_empty!(Identity, D) }
1343        }
1344
1345        #[inline]
1346        unsafe fn decode(
1347            &mut self,
1348            decoder: &mut fidl::encoding::Decoder<'_, D>,
1349            offset: usize,
1350            _depth: fidl::encoding::Depth,
1351        ) -> fidl::Result<()> {
1352            decoder.debug_check_bounds::<Self>(offset);
1353            // Verify that padding bytes are zero.
1354            fidl::decode!(Identity, D, &mut self.identity, decoder, offset + 0, _depth)?;
1355            Ok(())
1356        }
1357    }
1358
1359    impl fidl::encoding::ValueTypeMarker for DeviceGetSupportedNetworkTypesResponse {
1360        type Borrowed<'a> = &'a Self;
1361        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1362            value
1363        }
1364    }
1365
1366    unsafe impl fidl::encoding::TypeMarker for DeviceGetSupportedNetworkTypesResponse {
1367        type Owned = Self;
1368
1369        #[inline(always)]
1370        fn inline_align(_context: fidl::encoding::Context) -> usize {
1371            8
1372        }
1373
1374        #[inline(always)]
1375        fn inline_size(_context: fidl::encoding::Context) -> usize {
1376            16
1377        }
1378    }
1379
1380    unsafe impl<D: fidl::encoding::ResourceDialect>
1381        fidl::encoding::Encode<DeviceGetSupportedNetworkTypesResponse, D>
1382        for &DeviceGetSupportedNetworkTypesResponse
1383    {
1384        #[inline]
1385        unsafe fn encode(
1386            self,
1387            encoder: &mut fidl::encoding::Encoder<'_, D>,
1388            offset: usize,
1389            _depth: fidl::encoding::Depth,
1390        ) -> fidl::Result<()> {
1391            encoder.debug_check_bounds::<DeviceGetSupportedNetworkTypesResponse>(offset);
1392            // Delegate to tuple encoding.
1393            fidl::encoding::Encode::<DeviceGetSupportedNetworkTypesResponse, D>::encode(
1394                (
1395                    <fidl::encoding::Vector<fidl::encoding::BoundedString<64>, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.network_types),
1396                ),
1397                encoder, offset, _depth
1398            )
1399        }
1400    }
1401    unsafe impl<
1402            D: fidl::encoding::ResourceDialect,
1403            T0: fidl::encoding::Encode<
1404                fidl::encoding::Vector<fidl::encoding::BoundedString<64>, 16>,
1405                D,
1406            >,
1407        > fidl::encoding::Encode<DeviceGetSupportedNetworkTypesResponse, D> for (T0,)
1408    {
1409        #[inline]
1410        unsafe fn encode(
1411            self,
1412            encoder: &mut fidl::encoding::Encoder<'_, D>,
1413            offset: usize,
1414            depth: fidl::encoding::Depth,
1415        ) -> fidl::Result<()> {
1416            encoder.debug_check_bounds::<DeviceGetSupportedNetworkTypesResponse>(offset);
1417            // Zero out padding regions. There's no need to apply masks
1418            // because the unmasked parts will be overwritten by fields.
1419            // Write the fields.
1420            self.0.encode(encoder, offset + 0, depth)?;
1421            Ok(())
1422        }
1423    }
1424
1425    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1426        for DeviceGetSupportedNetworkTypesResponse
1427    {
1428        #[inline(always)]
1429        fn new_empty() -> Self {
1430            Self {
1431                network_types: fidl::new_empty!(
1432                    fidl::encoding::Vector<fidl::encoding::BoundedString<64>, 16>,
1433                    D
1434                ),
1435            }
1436        }
1437
1438        #[inline]
1439        unsafe fn decode(
1440            &mut self,
1441            decoder: &mut fidl::encoding::Decoder<'_, D>,
1442            offset: usize,
1443            _depth: fidl::encoding::Depth,
1444        ) -> fidl::Result<()> {
1445            decoder.debug_check_bounds::<Self>(offset);
1446            // Verify that padding bytes are zero.
1447            fidl::decode!(
1448                fidl::encoding::Vector<fidl::encoding::BoundedString<64>, 16>,
1449                D,
1450                &mut self.network_types,
1451                decoder,
1452                offset + 0,
1453                _depth
1454            )?;
1455            Ok(())
1456        }
1457    }
1458
1459    impl fidl::encoding::ValueTypeMarker for DeviceProvisionNetworkRequest {
1460        type Borrowed<'a> = &'a Self;
1461        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1462            value
1463        }
1464    }
1465
1466    unsafe impl fidl::encoding::TypeMarker for DeviceProvisionNetworkRequest {
1467        type Owned = Self;
1468
1469        #[inline(always)]
1470        fn inline_align(_context: fidl::encoding::Context) -> usize {
1471            8
1472        }
1473
1474        #[inline(always)]
1475        fn inline_size(_context: fidl::encoding::Context) -> usize {
1476            32
1477        }
1478    }
1479
1480    unsafe impl<D: fidl::encoding::ResourceDialect>
1481        fidl::encoding::Encode<DeviceProvisionNetworkRequest, D>
1482        for &DeviceProvisionNetworkRequest
1483    {
1484        #[inline]
1485        unsafe fn encode(
1486            self,
1487            encoder: &mut fidl::encoding::Encoder<'_, D>,
1488            offset: usize,
1489            _depth: fidl::encoding::Depth,
1490        ) -> fidl::Result<()> {
1491            encoder.debug_check_bounds::<DeviceProvisionNetworkRequest>(offset);
1492            // Delegate to tuple encoding.
1493            fidl::encoding::Encode::<DeviceProvisionNetworkRequest, D>::encode(
1494                (<ProvisioningParams as fidl::encoding::ValueTypeMarker>::borrow(&self.params),),
1495                encoder,
1496                offset,
1497                _depth,
1498            )
1499        }
1500    }
1501    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ProvisioningParams, D>>
1502        fidl::encoding::Encode<DeviceProvisionNetworkRequest, D> for (T0,)
1503    {
1504        #[inline]
1505        unsafe fn encode(
1506            self,
1507            encoder: &mut fidl::encoding::Encoder<'_, D>,
1508            offset: usize,
1509            depth: fidl::encoding::Depth,
1510        ) -> fidl::Result<()> {
1511            encoder.debug_check_bounds::<DeviceProvisionNetworkRequest>(offset);
1512            // Zero out padding regions. There's no need to apply masks
1513            // because the unmasked parts will be overwritten by fields.
1514            // Write the fields.
1515            self.0.encode(encoder, offset + 0, depth)?;
1516            Ok(())
1517        }
1518    }
1519
1520    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1521        for DeviceProvisionNetworkRequest
1522    {
1523        #[inline(always)]
1524        fn new_empty() -> Self {
1525            Self { params: fidl::new_empty!(ProvisioningParams, D) }
1526        }
1527
1528        #[inline]
1529        unsafe fn decode(
1530            &mut self,
1531            decoder: &mut fidl::encoding::Decoder<'_, D>,
1532            offset: usize,
1533            _depth: fidl::encoding::Depth,
1534        ) -> fidl::Result<()> {
1535            decoder.debug_check_bounds::<Self>(offset);
1536            // Verify that padding bytes are zero.
1537            fidl::decode!(ProvisioningParams, D, &mut self.params, decoder, offset + 0, _depth)?;
1538            Ok(())
1539        }
1540    }
1541
1542    impl fidl::encoding::ValueTypeMarker for DeviceSetActiveRequest {
1543        type Borrowed<'a> = &'a Self;
1544        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1545            value
1546        }
1547    }
1548
1549    unsafe impl fidl::encoding::TypeMarker for DeviceSetActiveRequest {
1550        type Owned = Self;
1551
1552        #[inline(always)]
1553        fn inline_align(_context: fidl::encoding::Context) -> usize {
1554            1
1555        }
1556
1557        #[inline(always)]
1558        fn inline_size(_context: fidl::encoding::Context) -> usize {
1559            1
1560        }
1561    }
1562
1563    unsafe impl<D: fidl::encoding::ResourceDialect>
1564        fidl::encoding::Encode<DeviceSetActiveRequest, D> for &DeviceSetActiveRequest
1565    {
1566        #[inline]
1567        unsafe fn encode(
1568            self,
1569            encoder: &mut fidl::encoding::Encoder<'_, D>,
1570            offset: usize,
1571            _depth: fidl::encoding::Depth,
1572        ) -> fidl::Result<()> {
1573            encoder.debug_check_bounds::<DeviceSetActiveRequest>(offset);
1574            // Delegate to tuple encoding.
1575            fidl::encoding::Encode::<DeviceSetActiveRequest, D>::encode(
1576                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.active),),
1577                encoder,
1578                offset,
1579                _depth,
1580            )
1581        }
1582    }
1583    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
1584        fidl::encoding::Encode<DeviceSetActiveRequest, D> for (T0,)
1585    {
1586        #[inline]
1587        unsafe fn encode(
1588            self,
1589            encoder: &mut fidl::encoding::Encoder<'_, D>,
1590            offset: usize,
1591            depth: fidl::encoding::Depth,
1592        ) -> fidl::Result<()> {
1593            encoder.debug_check_bounds::<DeviceSetActiveRequest>(offset);
1594            // Zero out padding regions. There's no need to apply masks
1595            // because the unmasked parts will be overwritten by fields.
1596            // Write the fields.
1597            self.0.encode(encoder, offset + 0, depth)?;
1598            Ok(())
1599        }
1600    }
1601
1602    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1603        for DeviceSetActiveRequest
1604    {
1605        #[inline(always)]
1606        fn new_empty() -> Self {
1607            Self { active: fidl::new_empty!(bool, D) }
1608        }
1609
1610        #[inline]
1611        unsafe fn decode(
1612            &mut self,
1613            decoder: &mut fidl::encoding::Decoder<'_, D>,
1614            offset: usize,
1615            _depth: fidl::encoding::Depth,
1616        ) -> fidl::Result<()> {
1617            decoder.debug_check_bounds::<Self>(offset);
1618            // Verify that padding bytes are zero.
1619            fidl::decode!(bool, D, &mut self.active, decoder, offset + 0, _depth)?;
1620            Ok(())
1621        }
1622    }
1623
1624    impl fidl::encoding::ValueTypeMarker for DeviceWatchDeviceStateResponse {
1625        type Borrowed<'a> = &'a Self;
1626        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1627            value
1628        }
1629    }
1630
1631    unsafe impl fidl::encoding::TypeMarker for DeviceWatchDeviceStateResponse {
1632        type Owned = Self;
1633
1634        #[inline(always)]
1635        fn inline_align(_context: fidl::encoding::Context) -> usize {
1636            8
1637        }
1638
1639        #[inline(always)]
1640        fn inline_size(_context: fidl::encoding::Context) -> usize {
1641            16
1642        }
1643    }
1644
1645    unsafe impl<D: fidl::encoding::ResourceDialect>
1646        fidl::encoding::Encode<DeviceWatchDeviceStateResponse, D>
1647        for &DeviceWatchDeviceStateResponse
1648    {
1649        #[inline]
1650        unsafe fn encode(
1651            self,
1652            encoder: &mut fidl::encoding::Encoder<'_, D>,
1653            offset: usize,
1654            _depth: fidl::encoding::Depth,
1655        ) -> fidl::Result<()> {
1656            encoder.debug_check_bounds::<DeviceWatchDeviceStateResponse>(offset);
1657            // Delegate to tuple encoding.
1658            fidl::encoding::Encode::<DeviceWatchDeviceStateResponse, D>::encode(
1659                (<DeviceState as fidl::encoding::ValueTypeMarker>::borrow(
1660                    &self.device_combined_state,
1661                ),),
1662                encoder,
1663                offset,
1664                _depth,
1665            )
1666        }
1667    }
1668    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<DeviceState, D>>
1669        fidl::encoding::Encode<DeviceWatchDeviceStateResponse, D> for (T0,)
1670    {
1671        #[inline]
1672        unsafe fn encode(
1673            self,
1674            encoder: &mut fidl::encoding::Encoder<'_, D>,
1675            offset: usize,
1676            depth: fidl::encoding::Depth,
1677        ) -> fidl::Result<()> {
1678            encoder.debug_check_bounds::<DeviceWatchDeviceStateResponse>(offset);
1679            // Zero out padding regions. There's no need to apply masks
1680            // because the unmasked parts will be overwritten by fields.
1681            // Write the fields.
1682            self.0.encode(encoder, offset + 0, depth)?;
1683            Ok(())
1684        }
1685    }
1686
1687    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1688        for DeviceWatchDeviceStateResponse
1689    {
1690        #[inline(always)]
1691        fn new_empty() -> Self {
1692            Self { device_combined_state: fidl::new_empty!(DeviceState, D) }
1693        }
1694
1695        #[inline]
1696        unsafe fn decode(
1697            &mut self,
1698            decoder: &mut fidl::encoding::Decoder<'_, D>,
1699            offset: usize,
1700            _depth: fidl::encoding::Depth,
1701        ) -> fidl::Result<()> {
1702            decoder.debug_check_bounds::<Self>(offset);
1703            // Verify that padding bytes are zero.
1704            fidl::decode!(
1705                DeviceState,
1706                D,
1707                &mut self.device_combined_state,
1708                decoder,
1709                offset + 0,
1710                _depth
1711            )?;
1712            Ok(())
1713        }
1714    }
1715
1716    impl fidl::encoding::ValueTypeMarker for EnergyScanResultStreamNextResponse {
1717        type Borrowed<'a> = &'a Self;
1718        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1719            value
1720        }
1721    }
1722
1723    unsafe impl fidl::encoding::TypeMarker for EnergyScanResultStreamNextResponse {
1724        type Owned = Self;
1725
1726        #[inline(always)]
1727        fn inline_align(_context: fidl::encoding::Context) -> usize {
1728            8
1729        }
1730
1731        #[inline(always)]
1732        fn inline_size(_context: fidl::encoding::Context) -> usize {
1733            16
1734        }
1735    }
1736
1737    unsafe impl<D: fidl::encoding::ResourceDialect>
1738        fidl::encoding::Encode<EnergyScanResultStreamNextResponse, D>
1739        for &EnergyScanResultStreamNextResponse
1740    {
1741        #[inline]
1742        unsafe fn encode(
1743            self,
1744            encoder: &mut fidl::encoding::Encoder<'_, D>,
1745            offset: usize,
1746            _depth: fidl::encoding::Depth,
1747        ) -> fidl::Result<()> {
1748            encoder.debug_check_bounds::<EnergyScanResultStreamNextResponse>(offset);
1749            // Delegate to tuple encoding.
1750            fidl::encoding::Encode::<EnergyScanResultStreamNextResponse, D>::encode(
1751                (
1752                    <fidl::encoding::Vector<EnergyScanResult, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.results),
1753                ),
1754                encoder, offset, _depth
1755            )
1756        }
1757    }
1758    unsafe impl<
1759            D: fidl::encoding::ResourceDialect,
1760            T0: fidl::encoding::Encode<fidl::encoding::Vector<EnergyScanResult, 32>, D>,
1761        > fidl::encoding::Encode<EnergyScanResultStreamNextResponse, D> for (T0,)
1762    {
1763        #[inline]
1764        unsafe fn encode(
1765            self,
1766            encoder: &mut fidl::encoding::Encoder<'_, D>,
1767            offset: usize,
1768            depth: fidl::encoding::Depth,
1769        ) -> fidl::Result<()> {
1770            encoder.debug_check_bounds::<EnergyScanResultStreamNextResponse>(offset);
1771            // Zero out padding regions. There's no need to apply masks
1772            // because the unmasked parts will be overwritten by fields.
1773            // Write the fields.
1774            self.0.encode(encoder, offset + 0, depth)?;
1775            Ok(())
1776        }
1777    }
1778
1779    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1780        for EnergyScanResultStreamNextResponse
1781    {
1782        #[inline(always)]
1783        fn new_empty() -> Self {
1784            Self { results: fidl::new_empty!(fidl::encoding::Vector<EnergyScanResult, 32>, D) }
1785        }
1786
1787        #[inline]
1788        unsafe fn decode(
1789            &mut self,
1790            decoder: &mut fidl::encoding::Decoder<'_, D>,
1791            offset: usize,
1792            _depth: fidl::encoding::Depth,
1793        ) -> fidl::Result<()> {
1794            decoder.debug_check_bounds::<Self>(offset);
1795            // Verify that padding bytes are zero.
1796            fidl::decode!(fidl::encoding::Vector<EnergyScanResult, 32>, D, &mut self.results, decoder, offset + 0, _depth)?;
1797            Ok(())
1798        }
1799    }
1800
1801    impl fidl::encoding::ValueTypeMarker for ProvisioningParams {
1802        type Borrowed<'a> = &'a Self;
1803        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1804            value
1805        }
1806    }
1807
1808    unsafe impl fidl::encoding::TypeMarker for ProvisioningParams {
1809        type Owned = Self;
1810
1811        #[inline(always)]
1812        fn inline_align(_context: fidl::encoding::Context) -> usize {
1813            8
1814        }
1815
1816        #[inline(always)]
1817        fn inline_size(_context: fidl::encoding::Context) -> usize {
1818            32
1819        }
1820    }
1821
1822    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProvisioningParams, D>
1823        for &ProvisioningParams
1824    {
1825        #[inline]
1826        unsafe fn encode(
1827            self,
1828            encoder: &mut fidl::encoding::Encoder<'_, D>,
1829            offset: usize,
1830            _depth: fidl::encoding::Depth,
1831        ) -> fidl::Result<()> {
1832            encoder.debug_check_bounds::<ProvisioningParams>(offset);
1833            // Delegate to tuple encoding.
1834            fidl::encoding::Encode::<ProvisioningParams, D>::encode(
1835                (
1836                    <Identity as fidl::encoding::ValueTypeMarker>::borrow(&self.identity),
1837                    <fidl::encoding::OptionalUnion<Credential> as fidl::encoding::ValueTypeMarker>::borrow(&self.credential),
1838                ),
1839                encoder, offset, _depth
1840            )
1841        }
1842    }
1843    unsafe impl<
1844            D: fidl::encoding::ResourceDialect,
1845            T0: fidl::encoding::Encode<Identity, D>,
1846            T1: fidl::encoding::Encode<fidl::encoding::OptionalUnion<Credential>, D>,
1847        > fidl::encoding::Encode<ProvisioningParams, D> for (T0, T1)
1848    {
1849        #[inline]
1850        unsafe fn encode(
1851            self,
1852            encoder: &mut fidl::encoding::Encoder<'_, D>,
1853            offset: usize,
1854            depth: fidl::encoding::Depth,
1855        ) -> fidl::Result<()> {
1856            encoder.debug_check_bounds::<ProvisioningParams>(offset);
1857            // Zero out padding regions. There's no need to apply masks
1858            // because the unmasked parts will be overwritten by fields.
1859            // Write the fields.
1860            self.0.encode(encoder, offset + 0, depth)?;
1861            self.1.encode(encoder, offset + 16, depth)?;
1862            Ok(())
1863        }
1864    }
1865
1866    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProvisioningParams {
1867        #[inline(always)]
1868        fn new_empty() -> Self {
1869            Self {
1870                identity: fidl::new_empty!(Identity, D),
1871                credential: fidl::new_empty!(fidl::encoding::OptionalUnion<Credential>, D),
1872            }
1873        }
1874
1875        #[inline]
1876        unsafe fn decode(
1877            &mut self,
1878            decoder: &mut fidl::encoding::Decoder<'_, D>,
1879            offset: usize,
1880            _depth: fidl::encoding::Depth,
1881        ) -> fidl::Result<()> {
1882            decoder.debug_check_bounds::<Self>(offset);
1883            // Verify that padding bytes are zero.
1884            fidl::decode!(Identity, D, &mut self.identity, decoder, offset + 0, _depth)?;
1885            fidl::decode!(
1886                fidl::encoding::OptionalUnion<Credential>,
1887                D,
1888                &mut self.credential,
1889                decoder,
1890                offset + 16,
1891                _depth
1892            )?;
1893            Ok(())
1894        }
1895    }
1896
1897    impl AllCounters {
1898        #[inline(always)]
1899        fn max_ordinal_present(&self) -> u64 {
1900            if let Some(_) = self.ip_rx {
1901                return 7;
1902            }
1903            if let Some(_) = self.ip_tx {
1904                return 6;
1905            }
1906            if let Some(_) = self.coex_saturated {
1907                return 5;
1908            }
1909            if let Some(_) = self.coex_rx {
1910                return 4;
1911            }
1912            if let Some(_) = self.coex_tx {
1913                return 3;
1914            }
1915            if let Some(_) = self.mac_rx {
1916                return 2;
1917            }
1918            if let Some(_) = self.mac_tx {
1919                return 1;
1920            }
1921            0
1922        }
1923    }
1924
1925    impl fidl::encoding::ValueTypeMarker for AllCounters {
1926        type Borrowed<'a> = &'a Self;
1927        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1928            value
1929        }
1930    }
1931
1932    unsafe impl fidl::encoding::TypeMarker for AllCounters {
1933        type Owned = Self;
1934
1935        #[inline(always)]
1936        fn inline_align(_context: fidl::encoding::Context) -> usize {
1937            8
1938        }
1939
1940        #[inline(always)]
1941        fn inline_size(_context: fidl::encoding::Context) -> usize {
1942            16
1943        }
1944    }
1945
1946    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllCounters, D>
1947        for &AllCounters
1948    {
1949        unsafe fn encode(
1950            self,
1951            encoder: &mut fidl::encoding::Encoder<'_, D>,
1952            offset: usize,
1953            mut depth: fidl::encoding::Depth,
1954        ) -> fidl::Result<()> {
1955            encoder.debug_check_bounds::<AllCounters>(offset);
1956            // Vector header
1957            let max_ordinal: u64 = self.max_ordinal_present();
1958            encoder.write_num(max_ordinal, offset);
1959            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1960            // Calling encoder.out_of_line_offset(0) is not allowed.
1961            if max_ordinal == 0 {
1962                return Ok(());
1963            }
1964            depth.increment()?;
1965            let envelope_size = 8;
1966            let bytes_len = max_ordinal as usize * envelope_size;
1967            #[allow(unused_variables)]
1968            let offset = encoder.out_of_line_offset(bytes_len);
1969            let mut _prev_end_offset: usize = 0;
1970            if 1 > max_ordinal {
1971                return Ok(());
1972            }
1973
1974            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1975            // are envelope_size bytes.
1976            let cur_offset: usize = (1 - 1) * envelope_size;
1977
1978            // Zero reserved fields.
1979            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1980
1981            // Safety:
1982            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1983            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1984            //   envelope_size bytes, there is always sufficient room.
1985            fidl::encoding::encode_in_envelope_optional::<MacCounters, D>(
1986                self.mac_tx.as_ref().map(<MacCounters as fidl::encoding::ValueTypeMarker>::borrow),
1987                encoder,
1988                offset + cur_offset,
1989                depth,
1990            )?;
1991
1992            _prev_end_offset = cur_offset + envelope_size;
1993            if 2 > max_ordinal {
1994                return Ok(());
1995            }
1996
1997            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1998            // are envelope_size bytes.
1999            let cur_offset: usize = (2 - 1) * envelope_size;
2000
2001            // Zero reserved fields.
2002            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2003
2004            // Safety:
2005            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2006            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2007            //   envelope_size bytes, there is always sufficient room.
2008            fidl::encoding::encode_in_envelope_optional::<MacCounters, D>(
2009                self.mac_rx.as_ref().map(<MacCounters as fidl::encoding::ValueTypeMarker>::borrow),
2010                encoder,
2011                offset + cur_offset,
2012                depth,
2013            )?;
2014
2015            _prev_end_offset = cur_offset + envelope_size;
2016            if 3 > max_ordinal {
2017                return Ok(());
2018            }
2019
2020            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2021            // are envelope_size bytes.
2022            let cur_offset: usize = (3 - 1) * envelope_size;
2023
2024            // Zero reserved fields.
2025            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2026
2027            // Safety:
2028            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2029            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2030            //   envelope_size bytes, there is always sufficient room.
2031            fidl::encoding::encode_in_envelope_optional::<CoexCounters, D>(
2032                self.coex_tx
2033                    .as_ref()
2034                    .map(<CoexCounters as fidl::encoding::ValueTypeMarker>::borrow),
2035                encoder,
2036                offset + cur_offset,
2037                depth,
2038            )?;
2039
2040            _prev_end_offset = cur_offset + envelope_size;
2041            if 4 > max_ordinal {
2042                return Ok(());
2043            }
2044
2045            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2046            // are envelope_size bytes.
2047            let cur_offset: usize = (4 - 1) * envelope_size;
2048
2049            // Zero reserved fields.
2050            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2051
2052            // Safety:
2053            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2054            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2055            //   envelope_size bytes, there is always sufficient room.
2056            fidl::encoding::encode_in_envelope_optional::<CoexCounters, D>(
2057                self.coex_rx
2058                    .as_ref()
2059                    .map(<CoexCounters as fidl::encoding::ValueTypeMarker>::borrow),
2060                encoder,
2061                offset + cur_offset,
2062                depth,
2063            )?;
2064
2065            _prev_end_offset = cur_offset + envelope_size;
2066            if 5 > max_ordinal {
2067                return Ok(());
2068            }
2069
2070            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2071            // are envelope_size bytes.
2072            let cur_offset: usize = (5 - 1) * envelope_size;
2073
2074            // Zero reserved fields.
2075            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2076
2077            // Safety:
2078            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2079            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2080            //   envelope_size bytes, there is always sufficient room.
2081            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2082                self.coex_saturated.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2083                encoder,
2084                offset + cur_offset,
2085                depth,
2086            )?;
2087
2088            _prev_end_offset = cur_offset + envelope_size;
2089            if 6 > max_ordinal {
2090                return Ok(());
2091            }
2092
2093            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2094            // are envelope_size bytes.
2095            let cur_offset: usize = (6 - 1) * envelope_size;
2096
2097            // Zero reserved fields.
2098            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2099
2100            // Safety:
2101            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2102            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2103            //   envelope_size bytes, there is always sufficient room.
2104            fidl::encoding::encode_in_envelope_optional::<IpCounters, D>(
2105                self.ip_tx.as_ref().map(<IpCounters as fidl::encoding::ValueTypeMarker>::borrow),
2106                encoder,
2107                offset + cur_offset,
2108                depth,
2109            )?;
2110
2111            _prev_end_offset = cur_offset + envelope_size;
2112            if 7 > max_ordinal {
2113                return Ok(());
2114            }
2115
2116            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2117            // are envelope_size bytes.
2118            let cur_offset: usize = (7 - 1) * envelope_size;
2119
2120            // Zero reserved fields.
2121            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2122
2123            // Safety:
2124            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2125            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2126            //   envelope_size bytes, there is always sufficient room.
2127            fidl::encoding::encode_in_envelope_optional::<IpCounters, D>(
2128                self.ip_rx.as_ref().map(<IpCounters as fidl::encoding::ValueTypeMarker>::borrow),
2129                encoder,
2130                offset + cur_offset,
2131                depth,
2132            )?;
2133
2134            _prev_end_offset = cur_offset + envelope_size;
2135
2136            Ok(())
2137        }
2138    }
2139
2140    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllCounters {
2141        #[inline(always)]
2142        fn new_empty() -> Self {
2143            Self::default()
2144        }
2145
2146        unsafe fn decode(
2147            &mut self,
2148            decoder: &mut fidl::encoding::Decoder<'_, D>,
2149            offset: usize,
2150            mut depth: fidl::encoding::Depth,
2151        ) -> fidl::Result<()> {
2152            decoder.debug_check_bounds::<Self>(offset);
2153            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2154                None => return Err(fidl::Error::NotNullable),
2155                Some(len) => len,
2156            };
2157            // Calling decoder.out_of_line_offset(0) is not allowed.
2158            if len == 0 {
2159                return Ok(());
2160            };
2161            depth.increment()?;
2162            let envelope_size = 8;
2163            let bytes_len = len * envelope_size;
2164            let offset = decoder.out_of_line_offset(bytes_len)?;
2165            // Decode the envelope for each type.
2166            let mut _next_ordinal_to_read = 0;
2167            let mut next_offset = offset;
2168            let end_offset = offset + bytes_len;
2169            _next_ordinal_to_read += 1;
2170            if next_offset >= end_offset {
2171                return Ok(());
2172            }
2173
2174            // Decode unknown envelopes for gaps in ordinals.
2175            while _next_ordinal_to_read < 1 {
2176                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2177                _next_ordinal_to_read += 1;
2178                next_offset += envelope_size;
2179            }
2180
2181            let next_out_of_line = decoder.next_out_of_line();
2182            let handles_before = decoder.remaining_handles();
2183            if let Some((inlined, num_bytes, num_handles)) =
2184                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2185            {
2186                let member_inline_size =
2187                    <MacCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2188                if inlined != (member_inline_size <= 4) {
2189                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2190                }
2191                let inner_offset;
2192                let mut inner_depth = depth.clone();
2193                if inlined {
2194                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2195                    inner_offset = next_offset;
2196                } else {
2197                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2198                    inner_depth.increment()?;
2199                }
2200                let val_ref = self.mac_tx.get_or_insert_with(|| fidl::new_empty!(MacCounters, D));
2201                fidl::decode!(MacCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
2202                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2203                {
2204                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2205                }
2206                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2207                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2208                }
2209            }
2210
2211            next_offset += envelope_size;
2212            _next_ordinal_to_read += 1;
2213            if next_offset >= end_offset {
2214                return Ok(());
2215            }
2216
2217            // Decode unknown envelopes for gaps in ordinals.
2218            while _next_ordinal_to_read < 2 {
2219                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2220                _next_ordinal_to_read += 1;
2221                next_offset += envelope_size;
2222            }
2223
2224            let next_out_of_line = decoder.next_out_of_line();
2225            let handles_before = decoder.remaining_handles();
2226            if let Some((inlined, num_bytes, num_handles)) =
2227                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2228            {
2229                let member_inline_size =
2230                    <MacCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2231                if inlined != (member_inline_size <= 4) {
2232                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2233                }
2234                let inner_offset;
2235                let mut inner_depth = depth.clone();
2236                if inlined {
2237                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2238                    inner_offset = next_offset;
2239                } else {
2240                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2241                    inner_depth.increment()?;
2242                }
2243                let val_ref = self.mac_rx.get_or_insert_with(|| fidl::new_empty!(MacCounters, D));
2244                fidl::decode!(MacCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
2245                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2246                {
2247                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2248                }
2249                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2250                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2251                }
2252            }
2253
2254            next_offset += envelope_size;
2255            _next_ordinal_to_read += 1;
2256            if next_offset >= end_offset {
2257                return Ok(());
2258            }
2259
2260            // Decode unknown envelopes for gaps in ordinals.
2261            while _next_ordinal_to_read < 3 {
2262                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2263                _next_ordinal_to_read += 1;
2264                next_offset += envelope_size;
2265            }
2266
2267            let next_out_of_line = decoder.next_out_of_line();
2268            let handles_before = decoder.remaining_handles();
2269            if let Some((inlined, num_bytes, num_handles)) =
2270                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2271            {
2272                let member_inline_size =
2273                    <CoexCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2274                if inlined != (member_inline_size <= 4) {
2275                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2276                }
2277                let inner_offset;
2278                let mut inner_depth = depth.clone();
2279                if inlined {
2280                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2281                    inner_offset = next_offset;
2282                } else {
2283                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2284                    inner_depth.increment()?;
2285                }
2286                let val_ref = self.coex_tx.get_or_insert_with(|| fidl::new_empty!(CoexCounters, D));
2287                fidl::decode!(CoexCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
2288                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2289                {
2290                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2291                }
2292                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2293                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2294                }
2295            }
2296
2297            next_offset += envelope_size;
2298            _next_ordinal_to_read += 1;
2299            if next_offset >= end_offset {
2300                return Ok(());
2301            }
2302
2303            // Decode unknown envelopes for gaps in ordinals.
2304            while _next_ordinal_to_read < 4 {
2305                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2306                _next_ordinal_to_read += 1;
2307                next_offset += envelope_size;
2308            }
2309
2310            let next_out_of_line = decoder.next_out_of_line();
2311            let handles_before = decoder.remaining_handles();
2312            if let Some((inlined, num_bytes, num_handles)) =
2313                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2314            {
2315                let member_inline_size =
2316                    <CoexCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2317                if inlined != (member_inline_size <= 4) {
2318                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2319                }
2320                let inner_offset;
2321                let mut inner_depth = depth.clone();
2322                if inlined {
2323                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2324                    inner_offset = next_offset;
2325                } else {
2326                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2327                    inner_depth.increment()?;
2328                }
2329                let val_ref = self.coex_rx.get_or_insert_with(|| fidl::new_empty!(CoexCounters, D));
2330                fidl::decode!(CoexCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
2331                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2332                {
2333                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2334                }
2335                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2336                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2337                }
2338            }
2339
2340            next_offset += envelope_size;
2341            _next_ordinal_to_read += 1;
2342            if next_offset >= end_offset {
2343                return Ok(());
2344            }
2345
2346            // Decode unknown envelopes for gaps in ordinals.
2347            while _next_ordinal_to_read < 5 {
2348                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2349                _next_ordinal_to_read += 1;
2350                next_offset += envelope_size;
2351            }
2352
2353            let next_out_of_line = decoder.next_out_of_line();
2354            let handles_before = decoder.remaining_handles();
2355            if let Some((inlined, num_bytes, num_handles)) =
2356                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2357            {
2358                let member_inline_size =
2359                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2360                if inlined != (member_inline_size <= 4) {
2361                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2362                }
2363                let inner_offset;
2364                let mut inner_depth = depth.clone();
2365                if inlined {
2366                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2367                    inner_offset = next_offset;
2368                } else {
2369                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2370                    inner_depth.increment()?;
2371                }
2372                let val_ref = self.coex_saturated.get_or_insert_with(|| fidl::new_empty!(bool, D));
2373                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2374                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2375                {
2376                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2377                }
2378                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2379                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2380                }
2381            }
2382
2383            next_offset += envelope_size;
2384            _next_ordinal_to_read += 1;
2385            if next_offset >= end_offset {
2386                return Ok(());
2387            }
2388
2389            // Decode unknown envelopes for gaps in ordinals.
2390            while _next_ordinal_to_read < 6 {
2391                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2392                _next_ordinal_to_read += 1;
2393                next_offset += envelope_size;
2394            }
2395
2396            let next_out_of_line = decoder.next_out_of_line();
2397            let handles_before = decoder.remaining_handles();
2398            if let Some((inlined, num_bytes, num_handles)) =
2399                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2400            {
2401                let member_inline_size =
2402                    <IpCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2403                if inlined != (member_inline_size <= 4) {
2404                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2405                }
2406                let inner_offset;
2407                let mut inner_depth = depth.clone();
2408                if inlined {
2409                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2410                    inner_offset = next_offset;
2411                } else {
2412                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2413                    inner_depth.increment()?;
2414                }
2415                let val_ref = self.ip_tx.get_or_insert_with(|| fidl::new_empty!(IpCounters, D));
2416                fidl::decode!(IpCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
2417                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2418                {
2419                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2420                }
2421                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2422                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2423                }
2424            }
2425
2426            next_offset += envelope_size;
2427            _next_ordinal_to_read += 1;
2428            if next_offset >= end_offset {
2429                return Ok(());
2430            }
2431
2432            // Decode unknown envelopes for gaps in ordinals.
2433            while _next_ordinal_to_read < 7 {
2434                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2435                _next_ordinal_to_read += 1;
2436                next_offset += envelope_size;
2437            }
2438
2439            let next_out_of_line = decoder.next_out_of_line();
2440            let handles_before = decoder.remaining_handles();
2441            if let Some((inlined, num_bytes, num_handles)) =
2442                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2443            {
2444                let member_inline_size =
2445                    <IpCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2446                if inlined != (member_inline_size <= 4) {
2447                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2448                }
2449                let inner_offset;
2450                let mut inner_depth = depth.clone();
2451                if inlined {
2452                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2453                    inner_offset = next_offset;
2454                } else {
2455                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2456                    inner_depth.increment()?;
2457                }
2458                let val_ref = self.ip_rx.get_or_insert_with(|| fidl::new_empty!(IpCounters, D));
2459                fidl::decode!(IpCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
2460                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2461                {
2462                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2463                }
2464                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2465                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2466                }
2467            }
2468
2469            next_offset += envelope_size;
2470
2471            // Decode the remaining unknown envelopes.
2472            while next_offset < end_offset {
2473                _next_ordinal_to_read += 1;
2474                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2475                next_offset += envelope_size;
2476            }
2477
2478            Ok(())
2479        }
2480    }
2481
2482    impl CoexCounters {
2483        #[inline(always)]
2484        fn max_ordinal_present(&self) -> u64 {
2485            if let Some(_) = self.grant_none {
2486                return 9;
2487            }
2488            if let Some(_) = self.avg_delay_request_to_grant_usec {
2489                return 8;
2490            }
2491            if let Some(_) = self.delayed_grant {
2492                return 7;
2493            }
2494            if let Some(_) = self.grant_deactivated_during_request {
2495                return 6;
2496            }
2497            if let Some(_) = self.grant_wait_timeout {
2498                return 5;
2499            }
2500            if let Some(_) = self.grant_wait_activated {
2501                return 4;
2502            }
2503            if let Some(_) = self.grant_wait {
2504                return 3;
2505            }
2506            if let Some(_) = self.grant_immediate {
2507                return 2;
2508            }
2509            if let Some(_) = self.requests {
2510                return 1;
2511            }
2512            0
2513        }
2514    }
2515
2516    impl fidl::encoding::ValueTypeMarker for CoexCounters {
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 CoexCounters {
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> fidl::encoding::Encode<CoexCounters, D>
2538        for &CoexCounters
2539    {
2540        unsafe fn encode(
2541            self,
2542            encoder: &mut fidl::encoding::Encoder<'_, D>,
2543            offset: usize,
2544            mut depth: fidl::encoding::Depth,
2545        ) -> fidl::Result<()> {
2546            encoder.debug_check_bounds::<CoexCounters>(offset);
2547            // Vector header
2548            let max_ordinal: u64 = self.max_ordinal_present();
2549            encoder.write_num(max_ordinal, offset);
2550            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2551            // Calling encoder.out_of_line_offset(0) is not allowed.
2552            if max_ordinal == 0 {
2553                return Ok(());
2554            }
2555            depth.increment()?;
2556            let envelope_size = 8;
2557            let bytes_len = max_ordinal as usize * envelope_size;
2558            #[allow(unused_variables)]
2559            let offset = encoder.out_of_line_offset(bytes_len);
2560            let mut _prev_end_offset: usize = 0;
2561            if 1 > max_ordinal {
2562                return Ok(());
2563            }
2564
2565            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2566            // are envelope_size bytes.
2567            let cur_offset: usize = (1 - 1) * envelope_size;
2568
2569            // Zero reserved fields.
2570            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2571
2572            // Safety:
2573            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2574            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2575            //   envelope_size bytes, there is always sufficient room.
2576            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2577                self.requests.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2578                encoder,
2579                offset + cur_offset,
2580                depth,
2581            )?;
2582
2583            _prev_end_offset = cur_offset + envelope_size;
2584            if 2 > max_ordinal {
2585                return Ok(());
2586            }
2587
2588            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2589            // are envelope_size bytes.
2590            let cur_offset: usize = (2 - 1) * envelope_size;
2591
2592            // Zero reserved fields.
2593            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2594
2595            // Safety:
2596            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2597            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2598            //   envelope_size bytes, there is always sufficient room.
2599            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2600                self.grant_immediate.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2601                encoder,
2602                offset + cur_offset,
2603                depth,
2604            )?;
2605
2606            _prev_end_offset = cur_offset + envelope_size;
2607            if 3 > max_ordinal {
2608                return Ok(());
2609            }
2610
2611            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2612            // are envelope_size bytes.
2613            let cur_offset: usize = (3 - 1) * envelope_size;
2614
2615            // Zero reserved fields.
2616            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2617
2618            // Safety:
2619            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2620            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2621            //   envelope_size bytes, there is always sufficient room.
2622            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2623                self.grant_wait.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2624                encoder,
2625                offset + cur_offset,
2626                depth,
2627            )?;
2628
2629            _prev_end_offset = cur_offset + envelope_size;
2630            if 4 > max_ordinal {
2631                return Ok(());
2632            }
2633
2634            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2635            // are envelope_size bytes.
2636            let cur_offset: usize = (4 - 1) * envelope_size;
2637
2638            // Zero reserved fields.
2639            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2640
2641            // Safety:
2642            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2643            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2644            //   envelope_size bytes, there is always sufficient room.
2645            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2646                self.grant_wait_activated
2647                    .as_ref()
2648                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2649                encoder,
2650                offset + cur_offset,
2651                depth,
2652            )?;
2653
2654            _prev_end_offset = cur_offset + envelope_size;
2655            if 5 > max_ordinal {
2656                return Ok(());
2657            }
2658
2659            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2660            // are envelope_size bytes.
2661            let cur_offset: usize = (5 - 1) * envelope_size;
2662
2663            // Zero reserved fields.
2664            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2665
2666            // Safety:
2667            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2668            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2669            //   envelope_size bytes, there is always sufficient room.
2670            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2671                self.grant_wait_timeout
2672                    .as_ref()
2673                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2674                encoder,
2675                offset + cur_offset,
2676                depth,
2677            )?;
2678
2679            _prev_end_offset = cur_offset + envelope_size;
2680            if 6 > max_ordinal {
2681                return Ok(());
2682            }
2683
2684            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2685            // are envelope_size bytes.
2686            let cur_offset: usize = (6 - 1) * envelope_size;
2687
2688            // Zero reserved fields.
2689            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2690
2691            // Safety:
2692            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2693            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2694            //   envelope_size bytes, there is always sufficient room.
2695            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2696                self.grant_deactivated_during_request
2697                    .as_ref()
2698                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2699                encoder,
2700                offset + cur_offset,
2701                depth,
2702            )?;
2703
2704            _prev_end_offset = cur_offset + envelope_size;
2705            if 7 > max_ordinal {
2706                return Ok(());
2707            }
2708
2709            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2710            // are envelope_size bytes.
2711            let cur_offset: usize = (7 - 1) * envelope_size;
2712
2713            // Zero reserved fields.
2714            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2715
2716            // Safety:
2717            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2718            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2719            //   envelope_size bytes, there is always sufficient room.
2720            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2721                self.delayed_grant.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2722                encoder,
2723                offset + cur_offset,
2724                depth,
2725            )?;
2726
2727            _prev_end_offset = cur_offset + envelope_size;
2728            if 8 > max_ordinal {
2729                return Ok(());
2730            }
2731
2732            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2733            // are envelope_size bytes.
2734            let cur_offset: usize = (8 - 1) * envelope_size;
2735
2736            // Zero reserved fields.
2737            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2738
2739            // Safety:
2740            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2741            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2742            //   envelope_size bytes, there is always sufficient room.
2743            fidl::encoding::encode_in_envelope_optional::<u32, D>(
2744                self.avg_delay_request_to_grant_usec
2745                    .as_ref()
2746                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2747                encoder,
2748                offset + cur_offset,
2749                depth,
2750            )?;
2751
2752            _prev_end_offset = cur_offset + envelope_size;
2753            if 9 > max_ordinal {
2754                return Ok(());
2755            }
2756
2757            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2758            // are envelope_size bytes.
2759            let cur_offset: usize = (9 - 1) * envelope_size;
2760
2761            // Zero reserved fields.
2762            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2763
2764            // Safety:
2765            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2766            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2767            //   envelope_size bytes, there is always sufficient room.
2768            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2769                self.grant_none.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2770                encoder,
2771                offset + cur_offset,
2772                depth,
2773            )?;
2774
2775            _prev_end_offset = cur_offset + envelope_size;
2776
2777            Ok(())
2778        }
2779    }
2780
2781    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CoexCounters {
2782        #[inline(always)]
2783        fn new_empty() -> Self {
2784            Self::default()
2785        }
2786
2787        unsafe fn decode(
2788            &mut self,
2789            decoder: &mut fidl::encoding::Decoder<'_, D>,
2790            offset: usize,
2791            mut depth: fidl::encoding::Depth,
2792        ) -> fidl::Result<()> {
2793            decoder.debug_check_bounds::<Self>(offset);
2794            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2795                None => return Err(fidl::Error::NotNullable),
2796                Some(len) => len,
2797            };
2798            // Calling decoder.out_of_line_offset(0) is not allowed.
2799            if len == 0 {
2800                return Ok(());
2801            };
2802            depth.increment()?;
2803            let envelope_size = 8;
2804            let bytes_len = len * envelope_size;
2805            let offset = decoder.out_of_line_offset(bytes_len)?;
2806            // Decode the envelope for each type.
2807            let mut _next_ordinal_to_read = 0;
2808            let mut next_offset = offset;
2809            let end_offset = offset + bytes_len;
2810            _next_ordinal_to_read += 1;
2811            if next_offset >= end_offset {
2812                return Ok(());
2813            }
2814
2815            // Decode unknown envelopes for gaps in ordinals.
2816            while _next_ordinal_to_read < 1 {
2817                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2818                _next_ordinal_to_read += 1;
2819                next_offset += envelope_size;
2820            }
2821
2822            let next_out_of_line = decoder.next_out_of_line();
2823            let handles_before = decoder.remaining_handles();
2824            if let Some((inlined, num_bytes, num_handles)) =
2825                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2826            {
2827                let member_inline_size =
2828                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2829                if inlined != (member_inline_size <= 4) {
2830                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2831                }
2832                let inner_offset;
2833                let mut inner_depth = depth.clone();
2834                if inlined {
2835                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2836                    inner_offset = next_offset;
2837                } else {
2838                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2839                    inner_depth.increment()?;
2840                }
2841                let val_ref = self.requests.get_or_insert_with(|| fidl::new_empty!(u64, D));
2842                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2843                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2844                {
2845                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2846                }
2847                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2848                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2849                }
2850            }
2851
2852            next_offset += envelope_size;
2853            _next_ordinal_to_read += 1;
2854            if next_offset >= end_offset {
2855                return Ok(());
2856            }
2857
2858            // Decode unknown envelopes for gaps in ordinals.
2859            while _next_ordinal_to_read < 2 {
2860                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2861                _next_ordinal_to_read += 1;
2862                next_offset += envelope_size;
2863            }
2864
2865            let next_out_of_line = decoder.next_out_of_line();
2866            let handles_before = decoder.remaining_handles();
2867            if let Some((inlined, num_bytes, num_handles)) =
2868                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2869            {
2870                let member_inline_size =
2871                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2872                if inlined != (member_inline_size <= 4) {
2873                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2874                }
2875                let inner_offset;
2876                let mut inner_depth = depth.clone();
2877                if inlined {
2878                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2879                    inner_offset = next_offset;
2880                } else {
2881                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2882                    inner_depth.increment()?;
2883                }
2884                let val_ref = self.grant_immediate.get_or_insert_with(|| fidl::new_empty!(u64, D));
2885                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2886                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2887                {
2888                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2889                }
2890                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2891                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2892                }
2893            }
2894
2895            next_offset += envelope_size;
2896            _next_ordinal_to_read += 1;
2897            if next_offset >= end_offset {
2898                return Ok(());
2899            }
2900
2901            // Decode unknown envelopes for gaps in ordinals.
2902            while _next_ordinal_to_read < 3 {
2903                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2904                _next_ordinal_to_read += 1;
2905                next_offset += envelope_size;
2906            }
2907
2908            let next_out_of_line = decoder.next_out_of_line();
2909            let handles_before = decoder.remaining_handles();
2910            if let Some((inlined, num_bytes, num_handles)) =
2911                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2912            {
2913                let member_inline_size =
2914                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2915                if inlined != (member_inline_size <= 4) {
2916                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2917                }
2918                let inner_offset;
2919                let mut inner_depth = depth.clone();
2920                if inlined {
2921                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2922                    inner_offset = next_offset;
2923                } else {
2924                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2925                    inner_depth.increment()?;
2926                }
2927                let val_ref = self.grant_wait.get_or_insert_with(|| fidl::new_empty!(u64, D));
2928                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2929                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2930                {
2931                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2932                }
2933                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2934                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2935                }
2936            }
2937
2938            next_offset += envelope_size;
2939            _next_ordinal_to_read += 1;
2940            if next_offset >= end_offset {
2941                return Ok(());
2942            }
2943
2944            // Decode unknown envelopes for gaps in ordinals.
2945            while _next_ordinal_to_read < 4 {
2946                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2947                _next_ordinal_to_read += 1;
2948                next_offset += envelope_size;
2949            }
2950
2951            let next_out_of_line = decoder.next_out_of_line();
2952            let handles_before = decoder.remaining_handles();
2953            if let Some((inlined, num_bytes, num_handles)) =
2954                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2955            {
2956                let member_inline_size =
2957                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2958                if inlined != (member_inline_size <= 4) {
2959                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2960                }
2961                let inner_offset;
2962                let mut inner_depth = depth.clone();
2963                if inlined {
2964                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2965                    inner_offset = next_offset;
2966                } else {
2967                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2968                    inner_depth.increment()?;
2969                }
2970                let val_ref =
2971                    self.grant_wait_activated.get_or_insert_with(|| fidl::new_empty!(u64, D));
2972                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2973                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2974                {
2975                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2976                }
2977                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2978                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2979                }
2980            }
2981
2982            next_offset += envelope_size;
2983            _next_ordinal_to_read += 1;
2984            if next_offset >= end_offset {
2985                return Ok(());
2986            }
2987
2988            // Decode unknown envelopes for gaps in ordinals.
2989            while _next_ordinal_to_read < 5 {
2990                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2991                _next_ordinal_to_read += 1;
2992                next_offset += envelope_size;
2993            }
2994
2995            let next_out_of_line = decoder.next_out_of_line();
2996            let handles_before = decoder.remaining_handles();
2997            if let Some((inlined, num_bytes, num_handles)) =
2998                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2999            {
3000                let member_inline_size =
3001                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3002                if inlined != (member_inline_size <= 4) {
3003                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3004                }
3005                let inner_offset;
3006                let mut inner_depth = depth.clone();
3007                if inlined {
3008                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3009                    inner_offset = next_offset;
3010                } else {
3011                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3012                    inner_depth.increment()?;
3013                }
3014                let val_ref =
3015                    self.grant_wait_timeout.get_or_insert_with(|| fidl::new_empty!(u64, D));
3016                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3017                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3018                {
3019                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3020                }
3021                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3022                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3023                }
3024            }
3025
3026            next_offset += envelope_size;
3027            _next_ordinal_to_read += 1;
3028            if next_offset >= end_offset {
3029                return Ok(());
3030            }
3031
3032            // Decode unknown envelopes for gaps in ordinals.
3033            while _next_ordinal_to_read < 6 {
3034                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3035                _next_ordinal_to_read += 1;
3036                next_offset += envelope_size;
3037            }
3038
3039            let next_out_of_line = decoder.next_out_of_line();
3040            let handles_before = decoder.remaining_handles();
3041            if let Some((inlined, num_bytes, num_handles)) =
3042                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3043            {
3044                let member_inline_size =
3045                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3046                if inlined != (member_inline_size <= 4) {
3047                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3048                }
3049                let inner_offset;
3050                let mut inner_depth = depth.clone();
3051                if inlined {
3052                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3053                    inner_offset = next_offset;
3054                } else {
3055                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3056                    inner_depth.increment()?;
3057                }
3058                let val_ref = self
3059                    .grant_deactivated_during_request
3060                    .get_or_insert_with(|| fidl::new_empty!(u64, D));
3061                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3062                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3063                {
3064                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3065                }
3066                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3067                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3068                }
3069            }
3070
3071            next_offset += envelope_size;
3072            _next_ordinal_to_read += 1;
3073            if next_offset >= end_offset {
3074                return Ok(());
3075            }
3076
3077            // Decode unknown envelopes for gaps in ordinals.
3078            while _next_ordinal_to_read < 7 {
3079                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3080                _next_ordinal_to_read += 1;
3081                next_offset += envelope_size;
3082            }
3083
3084            let next_out_of_line = decoder.next_out_of_line();
3085            let handles_before = decoder.remaining_handles();
3086            if let Some((inlined, num_bytes, num_handles)) =
3087                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3088            {
3089                let member_inline_size =
3090                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3091                if inlined != (member_inline_size <= 4) {
3092                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3093                }
3094                let inner_offset;
3095                let mut inner_depth = depth.clone();
3096                if inlined {
3097                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3098                    inner_offset = next_offset;
3099                } else {
3100                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3101                    inner_depth.increment()?;
3102                }
3103                let val_ref = self.delayed_grant.get_or_insert_with(|| fidl::new_empty!(u64, D));
3104                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3105                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3106                {
3107                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3108                }
3109                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3110                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3111                }
3112            }
3113
3114            next_offset += envelope_size;
3115            _next_ordinal_to_read += 1;
3116            if next_offset >= end_offset {
3117                return Ok(());
3118            }
3119
3120            // Decode unknown envelopes for gaps in ordinals.
3121            while _next_ordinal_to_read < 8 {
3122                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3123                _next_ordinal_to_read += 1;
3124                next_offset += envelope_size;
3125            }
3126
3127            let next_out_of_line = decoder.next_out_of_line();
3128            let handles_before = decoder.remaining_handles();
3129            if let Some((inlined, num_bytes, num_handles)) =
3130                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3131            {
3132                let member_inline_size =
3133                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3134                if inlined != (member_inline_size <= 4) {
3135                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3136                }
3137                let inner_offset;
3138                let mut inner_depth = depth.clone();
3139                if inlined {
3140                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3141                    inner_offset = next_offset;
3142                } else {
3143                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3144                    inner_depth.increment()?;
3145                }
3146                let val_ref = self
3147                    .avg_delay_request_to_grant_usec
3148                    .get_or_insert_with(|| fidl::new_empty!(u32, D));
3149                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3150                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3151                {
3152                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3153                }
3154                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3155                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3156                }
3157            }
3158
3159            next_offset += envelope_size;
3160            _next_ordinal_to_read += 1;
3161            if next_offset >= end_offset {
3162                return Ok(());
3163            }
3164
3165            // Decode unknown envelopes for gaps in ordinals.
3166            while _next_ordinal_to_read < 9 {
3167                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3168                _next_ordinal_to_read += 1;
3169                next_offset += envelope_size;
3170            }
3171
3172            let next_out_of_line = decoder.next_out_of_line();
3173            let handles_before = decoder.remaining_handles();
3174            if let Some((inlined, num_bytes, num_handles)) =
3175                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3176            {
3177                let member_inline_size =
3178                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3179                if inlined != (member_inline_size <= 4) {
3180                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3181                }
3182                let inner_offset;
3183                let mut inner_depth = depth.clone();
3184                if inlined {
3185                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3186                    inner_offset = next_offset;
3187                } else {
3188                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3189                    inner_depth.increment()?;
3190                }
3191                let val_ref = self.grant_none.get_or_insert_with(|| fidl::new_empty!(u64, D));
3192                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3193                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3194                {
3195                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3196                }
3197                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3198                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3199                }
3200            }
3201
3202            next_offset += envelope_size;
3203
3204            // Decode the remaining unknown envelopes.
3205            while next_offset < end_offset {
3206                _next_ordinal_to_read += 1;
3207                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3208                next_offset += envelope_size;
3209            }
3210
3211            Ok(())
3212        }
3213    }
3214
3215    impl DeviceState {
3216        #[inline(always)]
3217        fn max_ordinal_present(&self) -> u64 {
3218            if let Some(_) = self.role {
3219                return 2;
3220            }
3221            if let Some(_) = self.connectivity_state {
3222                return 1;
3223            }
3224            0
3225        }
3226    }
3227
3228    impl fidl::encoding::ValueTypeMarker for DeviceState {
3229        type Borrowed<'a> = &'a Self;
3230        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3231            value
3232        }
3233    }
3234
3235    unsafe impl fidl::encoding::TypeMarker for DeviceState {
3236        type Owned = Self;
3237
3238        #[inline(always)]
3239        fn inline_align(_context: fidl::encoding::Context) -> usize {
3240            8
3241        }
3242
3243        #[inline(always)]
3244        fn inline_size(_context: fidl::encoding::Context) -> usize {
3245            16
3246        }
3247    }
3248
3249    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceState, D>
3250        for &DeviceState
3251    {
3252        unsafe fn encode(
3253            self,
3254            encoder: &mut fidl::encoding::Encoder<'_, D>,
3255            offset: usize,
3256            mut depth: fidl::encoding::Depth,
3257        ) -> fidl::Result<()> {
3258            encoder.debug_check_bounds::<DeviceState>(offset);
3259            // Vector header
3260            let max_ordinal: u64 = self.max_ordinal_present();
3261            encoder.write_num(max_ordinal, offset);
3262            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3263            // Calling encoder.out_of_line_offset(0) is not allowed.
3264            if max_ordinal == 0 {
3265                return Ok(());
3266            }
3267            depth.increment()?;
3268            let envelope_size = 8;
3269            let bytes_len = max_ordinal as usize * envelope_size;
3270            #[allow(unused_variables)]
3271            let offset = encoder.out_of_line_offset(bytes_len);
3272            let mut _prev_end_offset: usize = 0;
3273            if 1 > max_ordinal {
3274                return Ok(());
3275            }
3276
3277            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3278            // are envelope_size bytes.
3279            let cur_offset: usize = (1 - 1) * envelope_size;
3280
3281            // Zero reserved fields.
3282            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3283
3284            // Safety:
3285            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3286            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3287            //   envelope_size bytes, there is always sufficient room.
3288            fidl::encoding::encode_in_envelope_optional::<ConnectivityState, D>(
3289                self.connectivity_state
3290                    .as_ref()
3291                    .map(<ConnectivityState as fidl::encoding::ValueTypeMarker>::borrow),
3292                encoder,
3293                offset + cur_offset,
3294                depth,
3295            )?;
3296
3297            _prev_end_offset = cur_offset + envelope_size;
3298            if 2 > max_ordinal {
3299                return Ok(());
3300            }
3301
3302            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3303            // are envelope_size bytes.
3304            let cur_offset: usize = (2 - 1) * envelope_size;
3305
3306            // Zero reserved fields.
3307            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3308
3309            // Safety:
3310            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3311            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3312            //   envelope_size bytes, there is always sufficient room.
3313            fidl::encoding::encode_in_envelope_optional::<Role, D>(
3314                self.role.as_ref().map(<Role as fidl::encoding::ValueTypeMarker>::borrow),
3315                encoder,
3316                offset + cur_offset,
3317                depth,
3318            )?;
3319
3320            _prev_end_offset = cur_offset + envelope_size;
3321
3322            Ok(())
3323        }
3324    }
3325
3326    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceState {
3327        #[inline(always)]
3328        fn new_empty() -> Self {
3329            Self::default()
3330        }
3331
3332        unsafe fn decode(
3333            &mut self,
3334            decoder: &mut fidl::encoding::Decoder<'_, D>,
3335            offset: usize,
3336            mut depth: fidl::encoding::Depth,
3337        ) -> fidl::Result<()> {
3338            decoder.debug_check_bounds::<Self>(offset);
3339            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3340                None => return Err(fidl::Error::NotNullable),
3341                Some(len) => len,
3342            };
3343            // Calling decoder.out_of_line_offset(0) is not allowed.
3344            if len == 0 {
3345                return Ok(());
3346            };
3347            depth.increment()?;
3348            let envelope_size = 8;
3349            let bytes_len = len * envelope_size;
3350            let offset = decoder.out_of_line_offset(bytes_len)?;
3351            // Decode the envelope for each type.
3352            let mut _next_ordinal_to_read = 0;
3353            let mut next_offset = offset;
3354            let end_offset = offset + bytes_len;
3355            _next_ordinal_to_read += 1;
3356            if next_offset >= end_offset {
3357                return Ok(());
3358            }
3359
3360            // Decode unknown envelopes for gaps in ordinals.
3361            while _next_ordinal_to_read < 1 {
3362                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3363                _next_ordinal_to_read += 1;
3364                next_offset += envelope_size;
3365            }
3366
3367            let next_out_of_line = decoder.next_out_of_line();
3368            let handles_before = decoder.remaining_handles();
3369            if let Some((inlined, num_bytes, num_handles)) =
3370                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3371            {
3372                let member_inline_size =
3373                    <ConnectivityState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3374                if inlined != (member_inline_size <= 4) {
3375                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3376                }
3377                let inner_offset;
3378                let mut inner_depth = depth.clone();
3379                if inlined {
3380                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3381                    inner_offset = next_offset;
3382                } else {
3383                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3384                    inner_depth.increment()?;
3385                }
3386                let val_ref = self
3387                    .connectivity_state
3388                    .get_or_insert_with(|| fidl::new_empty!(ConnectivityState, D));
3389                fidl::decode!(ConnectivityState, D, val_ref, decoder, inner_offset, inner_depth)?;
3390                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3391                {
3392                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3393                }
3394                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3395                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3396                }
3397            }
3398
3399            next_offset += envelope_size;
3400            _next_ordinal_to_read += 1;
3401            if next_offset >= end_offset {
3402                return Ok(());
3403            }
3404
3405            // Decode unknown envelopes for gaps in ordinals.
3406            while _next_ordinal_to_read < 2 {
3407                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3408                _next_ordinal_to_read += 1;
3409                next_offset += envelope_size;
3410            }
3411
3412            let next_out_of_line = decoder.next_out_of_line();
3413            let handles_before = decoder.remaining_handles();
3414            if let Some((inlined, num_bytes, num_handles)) =
3415                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3416            {
3417                let member_inline_size =
3418                    <Role as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3419                if inlined != (member_inline_size <= 4) {
3420                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3421                }
3422                let inner_offset;
3423                let mut inner_depth = depth.clone();
3424                if inlined {
3425                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3426                    inner_offset = next_offset;
3427                } else {
3428                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3429                    inner_depth.increment()?;
3430                }
3431                let val_ref = self.role.get_or_insert_with(|| fidl::new_empty!(Role, D));
3432                fidl::decode!(Role, D, val_ref, decoder, inner_offset, inner_depth)?;
3433                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3434                {
3435                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3436                }
3437                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3438                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3439                }
3440            }
3441
3442            next_offset += envelope_size;
3443
3444            // Decode the remaining unknown envelopes.
3445            while next_offset < end_offset {
3446                _next_ordinal_to_read += 1;
3447                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3448                next_offset += envelope_size;
3449            }
3450
3451            Ok(())
3452        }
3453    }
3454
3455    impl EnergyScanParameters {
3456        #[inline(always)]
3457        fn max_ordinal_present(&self) -> u64 {
3458            if let Some(_) = self.dwell_time_ms {
3459                return 2;
3460            }
3461            if let Some(_) = self.channels {
3462                return 1;
3463            }
3464            0
3465        }
3466    }
3467
3468    impl fidl::encoding::ValueTypeMarker for EnergyScanParameters {
3469        type Borrowed<'a> = &'a Self;
3470        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3471            value
3472        }
3473    }
3474
3475    unsafe impl fidl::encoding::TypeMarker for EnergyScanParameters {
3476        type Owned = Self;
3477
3478        #[inline(always)]
3479        fn inline_align(_context: fidl::encoding::Context) -> usize {
3480            8
3481        }
3482
3483        #[inline(always)]
3484        fn inline_size(_context: fidl::encoding::Context) -> usize {
3485            16
3486        }
3487    }
3488
3489    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EnergyScanParameters, D>
3490        for &EnergyScanParameters
3491    {
3492        unsafe fn encode(
3493            self,
3494            encoder: &mut fidl::encoding::Encoder<'_, D>,
3495            offset: usize,
3496            mut depth: fidl::encoding::Depth,
3497        ) -> fidl::Result<()> {
3498            encoder.debug_check_bounds::<EnergyScanParameters>(offset);
3499            // Vector header
3500            let max_ordinal: u64 = self.max_ordinal_present();
3501            encoder.write_num(max_ordinal, offset);
3502            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3503            // Calling encoder.out_of_line_offset(0) is not allowed.
3504            if max_ordinal == 0 {
3505                return Ok(());
3506            }
3507            depth.increment()?;
3508            let envelope_size = 8;
3509            let bytes_len = max_ordinal as usize * envelope_size;
3510            #[allow(unused_variables)]
3511            let offset = encoder.out_of_line_offset(bytes_len);
3512            let mut _prev_end_offset: usize = 0;
3513            if 1 > max_ordinal {
3514                return Ok(());
3515            }
3516
3517            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3518            // are envelope_size bytes.
3519            let cur_offset: usize = (1 - 1) * envelope_size;
3520
3521            // Zero reserved fields.
3522            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3523
3524            // Safety:
3525            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3526            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3527            //   envelope_size bytes, there is always sufficient room.
3528            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u16, 200>, D>(
3529                self.channels.as_ref().map(
3530                    <fidl::encoding::Vector<u16, 200> as fidl::encoding::ValueTypeMarker>::borrow,
3531                ),
3532                encoder,
3533                offset + cur_offset,
3534                depth,
3535            )?;
3536
3537            _prev_end_offset = cur_offset + envelope_size;
3538            if 2 > max_ordinal {
3539                return Ok(());
3540            }
3541
3542            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3543            // are envelope_size bytes.
3544            let cur_offset: usize = (2 - 1) * envelope_size;
3545
3546            // Zero reserved fields.
3547            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3548
3549            // Safety:
3550            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3551            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3552            //   envelope_size bytes, there is always sufficient room.
3553            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3554                self.dwell_time_ms.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3555                encoder,
3556                offset + cur_offset,
3557                depth,
3558            )?;
3559
3560            _prev_end_offset = cur_offset + envelope_size;
3561
3562            Ok(())
3563        }
3564    }
3565
3566    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnergyScanParameters {
3567        #[inline(always)]
3568        fn new_empty() -> Self {
3569            Self::default()
3570        }
3571
3572        unsafe fn decode(
3573            &mut self,
3574            decoder: &mut fidl::encoding::Decoder<'_, D>,
3575            offset: usize,
3576            mut depth: fidl::encoding::Depth,
3577        ) -> fidl::Result<()> {
3578            decoder.debug_check_bounds::<Self>(offset);
3579            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3580                None => return Err(fidl::Error::NotNullable),
3581                Some(len) => len,
3582            };
3583            // Calling decoder.out_of_line_offset(0) is not allowed.
3584            if len == 0 {
3585                return Ok(());
3586            };
3587            depth.increment()?;
3588            let envelope_size = 8;
3589            let bytes_len = len * envelope_size;
3590            let offset = decoder.out_of_line_offset(bytes_len)?;
3591            // Decode the envelope for each type.
3592            let mut _next_ordinal_to_read = 0;
3593            let mut next_offset = offset;
3594            let end_offset = offset + bytes_len;
3595            _next_ordinal_to_read += 1;
3596            if next_offset >= end_offset {
3597                return Ok(());
3598            }
3599
3600            // Decode unknown envelopes for gaps in ordinals.
3601            while _next_ordinal_to_read < 1 {
3602                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3603                _next_ordinal_to_read += 1;
3604                next_offset += envelope_size;
3605            }
3606
3607            let next_out_of_line = decoder.next_out_of_line();
3608            let handles_before = decoder.remaining_handles();
3609            if let Some((inlined, num_bytes, num_handles)) =
3610                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3611            {
3612                let member_inline_size =
3613                    <fidl::encoding::Vector<u16, 200> as fidl::encoding::TypeMarker>::inline_size(
3614                        decoder.context,
3615                    );
3616                if inlined != (member_inline_size <= 4) {
3617                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3618                }
3619                let inner_offset;
3620                let mut inner_depth = depth.clone();
3621                if inlined {
3622                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3623                    inner_offset = next_offset;
3624                } else {
3625                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3626                    inner_depth.increment()?;
3627                }
3628                let val_ref = self
3629                    .channels
3630                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u16, 200>, D));
3631                fidl::decode!(fidl::encoding::Vector<u16, 200>, D, val_ref, decoder, inner_offset, inner_depth)?;
3632                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3633                {
3634                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3635                }
3636                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3637                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3638                }
3639            }
3640
3641            next_offset += envelope_size;
3642            _next_ordinal_to_read += 1;
3643            if next_offset >= end_offset {
3644                return Ok(());
3645            }
3646
3647            // Decode unknown envelopes for gaps in ordinals.
3648            while _next_ordinal_to_read < 2 {
3649                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3650                _next_ordinal_to_read += 1;
3651                next_offset += envelope_size;
3652            }
3653
3654            let next_out_of_line = decoder.next_out_of_line();
3655            let handles_before = decoder.remaining_handles();
3656            if let Some((inlined, num_bytes, num_handles)) =
3657                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3658            {
3659                let member_inline_size =
3660                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3661                if inlined != (member_inline_size <= 4) {
3662                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3663                }
3664                let inner_offset;
3665                let mut inner_depth = depth.clone();
3666                if inlined {
3667                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3668                    inner_offset = next_offset;
3669                } else {
3670                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3671                    inner_depth.increment()?;
3672                }
3673                let val_ref = self.dwell_time_ms.get_or_insert_with(|| fidl::new_empty!(u32, D));
3674                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3675                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3676                {
3677                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3678                }
3679                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3680                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3681                }
3682            }
3683
3684            next_offset += envelope_size;
3685
3686            // Decode the remaining unknown envelopes.
3687            while next_offset < end_offset {
3688                _next_ordinal_to_read += 1;
3689                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3690                next_offset += envelope_size;
3691            }
3692
3693            Ok(())
3694        }
3695    }
3696
3697    impl EnergyScanResult {
3698        #[inline(always)]
3699        fn max_ordinal_present(&self) -> u64 {
3700            if let Some(_) = self.min_rssi {
3701                return 3;
3702            }
3703            if let Some(_) = self.max_rssi {
3704                return 2;
3705            }
3706            if let Some(_) = self.channel_index {
3707                return 1;
3708            }
3709            0
3710        }
3711    }
3712
3713    impl fidl::encoding::ValueTypeMarker for EnergyScanResult {
3714        type Borrowed<'a> = &'a Self;
3715        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3716            value
3717        }
3718    }
3719
3720    unsafe impl fidl::encoding::TypeMarker for EnergyScanResult {
3721        type Owned = Self;
3722
3723        #[inline(always)]
3724        fn inline_align(_context: fidl::encoding::Context) -> usize {
3725            8
3726        }
3727
3728        #[inline(always)]
3729        fn inline_size(_context: fidl::encoding::Context) -> usize {
3730            16
3731        }
3732    }
3733
3734    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EnergyScanResult, D>
3735        for &EnergyScanResult
3736    {
3737        unsafe fn encode(
3738            self,
3739            encoder: &mut fidl::encoding::Encoder<'_, D>,
3740            offset: usize,
3741            mut depth: fidl::encoding::Depth,
3742        ) -> fidl::Result<()> {
3743            encoder.debug_check_bounds::<EnergyScanResult>(offset);
3744            // Vector header
3745            let max_ordinal: u64 = self.max_ordinal_present();
3746            encoder.write_num(max_ordinal, offset);
3747            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3748            // Calling encoder.out_of_line_offset(0) is not allowed.
3749            if max_ordinal == 0 {
3750                return Ok(());
3751            }
3752            depth.increment()?;
3753            let envelope_size = 8;
3754            let bytes_len = max_ordinal as usize * envelope_size;
3755            #[allow(unused_variables)]
3756            let offset = encoder.out_of_line_offset(bytes_len);
3757            let mut _prev_end_offset: usize = 0;
3758            if 1 > max_ordinal {
3759                return Ok(());
3760            }
3761
3762            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3763            // are envelope_size bytes.
3764            let cur_offset: usize = (1 - 1) * envelope_size;
3765
3766            // Zero reserved fields.
3767            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3768
3769            // Safety:
3770            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3771            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3772            //   envelope_size bytes, there is always sufficient room.
3773            fidl::encoding::encode_in_envelope_optional::<u16, D>(
3774                self.channel_index.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3775                encoder,
3776                offset + cur_offset,
3777                depth,
3778            )?;
3779
3780            _prev_end_offset = cur_offset + envelope_size;
3781            if 2 > max_ordinal {
3782                return Ok(());
3783            }
3784
3785            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3786            // are envelope_size bytes.
3787            let cur_offset: usize = (2 - 1) * envelope_size;
3788
3789            // Zero reserved fields.
3790            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3791
3792            // Safety:
3793            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3794            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3795            //   envelope_size bytes, there is always sufficient room.
3796            fidl::encoding::encode_in_envelope_optional::<i32, D>(
3797                self.max_rssi.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
3798                encoder,
3799                offset + cur_offset,
3800                depth,
3801            )?;
3802
3803            _prev_end_offset = cur_offset + envelope_size;
3804            if 3 > max_ordinal {
3805                return Ok(());
3806            }
3807
3808            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3809            // are envelope_size bytes.
3810            let cur_offset: usize = (3 - 1) * envelope_size;
3811
3812            // Zero reserved fields.
3813            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3814
3815            // Safety:
3816            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3817            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3818            //   envelope_size bytes, there is always sufficient room.
3819            fidl::encoding::encode_in_envelope_optional::<i32, D>(
3820                self.min_rssi.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
3821                encoder,
3822                offset + cur_offset,
3823                depth,
3824            )?;
3825
3826            _prev_end_offset = cur_offset + envelope_size;
3827
3828            Ok(())
3829        }
3830    }
3831
3832    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnergyScanResult {
3833        #[inline(always)]
3834        fn new_empty() -> Self {
3835            Self::default()
3836        }
3837
3838        unsafe fn decode(
3839            &mut self,
3840            decoder: &mut fidl::encoding::Decoder<'_, D>,
3841            offset: usize,
3842            mut depth: fidl::encoding::Depth,
3843        ) -> fidl::Result<()> {
3844            decoder.debug_check_bounds::<Self>(offset);
3845            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3846                None => return Err(fidl::Error::NotNullable),
3847                Some(len) => len,
3848            };
3849            // Calling decoder.out_of_line_offset(0) is not allowed.
3850            if len == 0 {
3851                return Ok(());
3852            };
3853            depth.increment()?;
3854            let envelope_size = 8;
3855            let bytes_len = len * envelope_size;
3856            let offset = decoder.out_of_line_offset(bytes_len)?;
3857            // Decode the envelope for each type.
3858            let mut _next_ordinal_to_read = 0;
3859            let mut next_offset = offset;
3860            let end_offset = offset + bytes_len;
3861            _next_ordinal_to_read += 1;
3862            if next_offset >= end_offset {
3863                return Ok(());
3864            }
3865
3866            // Decode unknown envelopes for gaps in ordinals.
3867            while _next_ordinal_to_read < 1 {
3868                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3869                _next_ordinal_to_read += 1;
3870                next_offset += envelope_size;
3871            }
3872
3873            let next_out_of_line = decoder.next_out_of_line();
3874            let handles_before = decoder.remaining_handles();
3875            if let Some((inlined, num_bytes, num_handles)) =
3876                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3877            {
3878                let member_inline_size =
3879                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3880                if inlined != (member_inline_size <= 4) {
3881                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3882                }
3883                let inner_offset;
3884                let mut inner_depth = depth.clone();
3885                if inlined {
3886                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3887                    inner_offset = next_offset;
3888                } else {
3889                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3890                    inner_depth.increment()?;
3891                }
3892                let val_ref = self.channel_index.get_or_insert_with(|| fidl::new_empty!(u16, D));
3893                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
3894                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3895                {
3896                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3897                }
3898                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3899                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3900                }
3901            }
3902
3903            next_offset += envelope_size;
3904            _next_ordinal_to_read += 1;
3905            if next_offset >= end_offset {
3906                return Ok(());
3907            }
3908
3909            // Decode unknown envelopes for gaps in ordinals.
3910            while _next_ordinal_to_read < 2 {
3911                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3912                _next_ordinal_to_read += 1;
3913                next_offset += envelope_size;
3914            }
3915
3916            let next_out_of_line = decoder.next_out_of_line();
3917            let handles_before = decoder.remaining_handles();
3918            if let Some((inlined, num_bytes, num_handles)) =
3919                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3920            {
3921                let member_inline_size =
3922                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3923                if inlined != (member_inline_size <= 4) {
3924                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3925                }
3926                let inner_offset;
3927                let mut inner_depth = depth.clone();
3928                if inlined {
3929                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3930                    inner_offset = next_offset;
3931                } else {
3932                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3933                    inner_depth.increment()?;
3934                }
3935                let val_ref = self.max_rssi.get_or_insert_with(|| fidl::new_empty!(i32, D));
3936                fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
3937                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3938                {
3939                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3940                }
3941                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3942                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3943                }
3944            }
3945
3946            next_offset += envelope_size;
3947            _next_ordinal_to_read += 1;
3948            if next_offset >= end_offset {
3949                return Ok(());
3950            }
3951
3952            // Decode unknown envelopes for gaps in ordinals.
3953            while _next_ordinal_to_read < 3 {
3954                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3955                _next_ordinal_to_read += 1;
3956                next_offset += envelope_size;
3957            }
3958
3959            let next_out_of_line = decoder.next_out_of_line();
3960            let handles_before = decoder.remaining_handles();
3961            if let Some((inlined, num_bytes, num_handles)) =
3962                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3963            {
3964                let member_inline_size =
3965                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3966                if inlined != (member_inline_size <= 4) {
3967                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3968                }
3969                let inner_offset;
3970                let mut inner_depth = depth.clone();
3971                if inlined {
3972                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3973                    inner_offset = next_offset;
3974                } else {
3975                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3976                    inner_depth.increment()?;
3977                }
3978                let val_ref = self.min_rssi.get_or_insert_with(|| fidl::new_empty!(i32, D));
3979                fidl::decode!(i32, D, val_ref, decoder, inner_offset, inner_depth)?;
3980                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3981                {
3982                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3983                }
3984                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3985                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3986                }
3987            }
3988
3989            next_offset += envelope_size;
3990
3991            // Decode the remaining unknown envelopes.
3992            while next_offset < end_offset {
3993                _next_ordinal_to_read += 1;
3994                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3995                next_offset += envelope_size;
3996            }
3997
3998            Ok(())
3999        }
4000    }
4001
4002    impl Identity {
4003        #[inline(always)]
4004        fn max_ordinal_present(&self) -> u64 {
4005            if let Some(_) = self.xpanid {
4006                return 7;
4007            }
4008            if let Some(_) = self.mesh_local_prefix {
4009                return 6;
4010            }
4011            if let Some(_) = self.panid {
4012                return 5;
4013            }
4014            if let Some(_) = self.channel {
4015                return 4;
4016            }
4017            if let Some(_) = self.net_type {
4018                return 3;
4019            }
4020            if let Some(_) = self.raw_name {
4021                return 1;
4022            }
4023            0
4024        }
4025    }
4026
4027    impl fidl::encoding::ValueTypeMarker for Identity {
4028        type Borrowed<'a> = &'a Self;
4029        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4030            value
4031        }
4032    }
4033
4034    unsafe impl fidl::encoding::TypeMarker for Identity {
4035        type Owned = Self;
4036
4037        #[inline(always)]
4038        fn inline_align(_context: fidl::encoding::Context) -> usize {
4039            8
4040        }
4041
4042        #[inline(always)]
4043        fn inline_size(_context: fidl::encoding::Context) -> usize {
4044            16
4045        }
4046    }
4047
4048    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Identity, D> for &Identity {
4049        unsafe fn encode(
4050            self,
4051            encoder: &mut fidl::encoding::Encoder<'_, D>,
4052            offset: usize,
4053            mut depth: fidl::encoding::Depth,
4054        ) -> fidl::Result<()> {
4055            encoder.debug_check_bounds::<Identity>(offset);
4056            // Vector header
4057            let max_ordinal: u64 = self.max_ordinal_present();
4058            encoder.write_num(max_ordinal, offset);
4059            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4060            // Calling encoder.out_of_line_offset(0) is not allowed.
4061            if max_ordinal == 0 {
4062                return Ok(());
4063            }
4064            depth.increment()?;
4065            let envelope_size = 8;
4066            let bytes_len = max_ordinal as usize * envelope_size;
4067            #[allow(unused_variables)]
4068            let offset = encoder.out_of_line_offset(bytes_len);
4069            let mut _prev_end_offset: usize = 0;
4070            if 1 > max_ordinal {
4071                return Ok(());
4072            }
4073
4074            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4075            // are envelope_size bytes.
4076            let cur_offset: usize = (1 - 1) * envelope_size;
4077
4078            // Zero reserved fields.
4079            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4080
4081            // Safety:
4082            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4083            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4084            //   envelope_size bytes, there is always sufficient room.
4085            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 63>, D>(
4086                self.raw_name.as_ref().map(
4087                    <fidl::encoding::Vector<u8, 63> as fidl::encoding::ValueTypeMarker>::borrow,
4088                ),
4089                encoder,
4090                offset + cur_offset,
4091                depth,
4092            )?;
4093
4094            _prev_end_offset = cur_offset + envelope_size;
4095            if 3 > max_ordinal {
4096                return Ok(());
4097            }
4098
4099            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4100            // are envelope_size bytes.
4101            let cur_offset: usize = (3 - 1) * envelope_size;
4102
4103            // Zero reserved fields.
4104            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4105
4106            // Safety:
4107            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4108            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4109            //   envelope_size bytes, there is always sufficient room.
4110            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
4111                self.net_type.as_ref().map(
4112                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
4113                ),
4114                encoder,
4115                offset + cur_offset,
4116                depth,
4117            )?;
4118
4119            _prev_end_offset = cur_offset + envelope_size;
4120            if 4 > max_ordinal {
4121                return Ok(());
4122            }
4123
4124            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4125            // are envelope_size bytes.
4126            let cur_offset: usize = (4 - 1) * envelope_size;
4127
4128            // Zero reserved fields.
4129            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4130
4131            // Safety:
4132            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4133            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4134            //   envelope_size bytes, there is always sufficient room.
4135            fidl::encoding::encode_in_envelope_optional::<u16, D>(
4136                self.channel.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4137                encoder,
4138                offset + cur_offset,
4139                depth,
4140            )?;
4141
4142            _prev_end_offset = cur_offset + envelope_size;
4143            if 5 > max_ordinal {
4144                return Ok(());
4145            }
4146
4147            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4148            // are envelope_size bytes.
4149            let cur_offset: usize = (5 - 1) * envelope_size;
4150
4151            // Zero reserved fields.
4152            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4153
4154            // Safety:
4155            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4156            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4157            //   envelope_size bytes, there is always sufficient room.
4158            fidl::encoding::encode_in_envelope_optional::<u16, D>(
4159                self.panid.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4160                encoder,
4161                offset + cur_offset,
4162                depth,
4163            )?;
4164
4165            _prev_end_offset = cur_offset + envelope_size;
4166            if 6 > max_ordinal {
4167                return Ok(());
4168            }
4169
4170            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4171            // are envelope_size bytes.
4172            let cur_offset: usize = (6 - 1) * envelope_size;
4173
4174            // Zero reserved fields.
4175            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4176
4177            // Safety:
4178            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4179            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4180            //   envelope_size bytes, there is always sufficient room.
4181            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>(
4182            self.mesh_local_prefix.as_ref().map(<fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow),
4183            encoder, offset + cur_offset, depth
4184        )?;
4185
4186            _prev_end_offset = cur_offset + envelope_size;
4187            if 7 > max_ordinal {
4188                return Ok(());
4189            }
4190
4191            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4192            // are envelope_size bytes.
4193            let cur_offset: usize = (7 - 1) * envelope_size;
4194
4195            // Zero reserved fields.
4196            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4197
4198            // Safety:
4199            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4200            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4201            //   envelope_size bytes, there is always sufficient room.
4202            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 8>, D>(
4203                self.xpanid
4204                    .as_ref()
4205                    .map(<fidl::encoding::Array<u8, 8> as fidl::encoding::ValueTypeMarker>::borrow),
4206                encoder,
4207                offset + cur_offset,
4208                depth,
4209            )?;
4210
4211            _prev_end_offset = cur_offset + envelope_size;
4212
4213            Ok(())
4214        }
4215    }
4216
4217    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Identity {
4218        #[inline(always)]
4219        fn new_empty() -> Self {
4220            Self::default()
4221        }
4222
4223        unsafe fn decode(
4224            &mut self,
4225            decoder: &mut fidl::encoding::Decoder<'_, D>,
4226            offset: usize,
4227            mut depth: fidl::encoding::Depth,
4228        ) -> fidl::Result<()> {
4229            decoder.debug_check_bounds::<Self>(offset);
4230            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4231                None => return Err(fidl::Error::NotNullable),
4232                Some(len) => len,
4233            };
4234            // Calling decoder.out_of_line_offset(0) is not allowed.
4235            if len == 0 {
4236                return Ok(());
4237            };
4238            depth.increment()?;
4239            let envelope_size = 8;
4240            let bytes_len = len * envelope_size;
4241            let offset = decoder.out_of_line_offset(bytes_len)?;
4242            // Decode the envelope for each type.
4243            let mut _next_ordinal_to_read = 0;
4244            let mut next_offset = offset;
4245            let end_offset = offset + bytes_len;
4246            _next_ordinal_to_read += 1;
4247            if next_offset >= end_offset {
4248                return Ok(());
4249            }
4250
4251            // Decode unknown envelopes for gaps in ordinals.
4252            while _next_ordinal_to_read < 1 {
4253                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4254                _next_ordinal_to_read += 1;
4255                next_offset += envelope_size;
4256            }
4257
4258            let next_out_of_line = decoder.next_out_of_line();
4259            let handles_before = decoder.remaining_handles();
4260            if let Some((inlined, num_bytes, num_handles)) =
4261                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4262            {
4263                let member_inline_size =
4264                    <fidl::encoding::Vector<u8, 63> as fidl::encoding::TypeMarker>::inline_size(
4265                        decoder.context,
4266                    );
4267                if inlined != (member_inline_size <= 4) {
4268                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4269                }
4270                let inner_offset;
4271                let mut inner_depth = depth.clone();
4272                if inlined {
4273                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4274                    inner_offset = next_offset;
4275                } else {
4276                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4277                    inner_depth.increment()?;
4278                }
4279                let val_ref = self
4280                    .raw_name
4281                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 63>, D));
4282                fidl::decode!(fidl::encoding::Vector<u8, 63>, D, val_ref, decoder, inner_offset, inner_depth)?;
4283                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4284                {
4285                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4286                }
4287                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4288                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4289                }
4290            }
4291
4292            next_offset += envelope_size;
4293            _next_ordinal_to_read += 1;
4294            if next_offset >= end_offset {
4295                return Ok(());
4296            }
4297
4298            // Decode unknown envelopes for gaps in ordinals.
4299            while _next_ordinal_to_read < 3 {
4300                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4301                _next_ordinal_to_read += 1;
4302                next_offset += envelope_size;
4303            }
4304
4305            let next_out_of_line = decoder.next_out_of_line();
4306            let handles_before = decoder.remaining_handles();
4307            if let Some((inlined, num_bytes, num_handles)) =
4308                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4309            {
4310                let member_inline_size =
4311                    <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
4312                        decoder.context,
4313                    );
4314                if inlined != (member_inline_size <= 4) {
4315                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4316                }
4317                let inner_offset;
4318                let mut inner_depth = depth.clone();
4319                if inlined {
4320                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4321                    inner_offset = next_offset;
4322                } else {
4323                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4324                    inner_depth.increment()?;
4325                }
4326                let val_ref = self
4327                    .net_type
4328                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
4329                fidl::decode!(
4330                    fidl::encoding::BoundedString<64>,
4331                    D,
4332                    val_ref,
4333                    decoder,
4334                    inner_offset,
4335                    inner_depth
4336                )?;
4337                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4338                {
4339                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4340                }
4341                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4342                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4343                }
4344            }
4345
4346            next_offset += envelope_size;
4347            _next_ordinal_to_read += 1;
4348            if next_offset >= end_offset {
4349                return Ok(());
4350            }
4351
4352            // Decode unknown envelopes for gaps in ordinals.
4353            while _next_ordinal_to_read < 4 {
4354                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4355                _next_ordinal_to_read += 1;
4356                next_offset += envelope_size;
4357            }
4358
4359            let next_out_of_line = decoder.next_out_of_line();
4360            let handles_before = decoder.remaining_handles();
4361            if let Some((inlined, num_bytes, num_handles)) =
4362                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4363            {
4364                let member_inline_size =
4365                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4366                if inlined != (member_inline_size <= 4) {
4367                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4368                }
4369                let inner_offset;
4370                let mut inner_depth = depth.clone();
4371                if inlined {
4372                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4373                    inner_offset = next_offset;
4374                } else {
4375                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4376                    inner_depth.increment()?;
4377                }
4378                let val_ref = self.channel.get_or_insert_with(|| fidl::new_empty!(u16, D));
4379                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4380                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4381                {
4382                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4383                }
4384                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4385                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4386                }
4387            }
4388
4389            next_offset += envelope_size;
4390            _next_ordinal_to_read += 1;
4391            if next_offset >= end_offset {
4392                return Ok(());
4393            }
4394
4395            // Decode unknown envelopes for gaps in ordinals.
4396            while _next_ordinal_to_read < 5 {
4397                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4398                _next_ordinal_to_read += 1;
4399                next_offset += envelope_size;
4400            }
4401
4402            let next_out_of_line = decoder.next_out_of_line();
4403            let handles_before = decoder.remaining_handles();
4404            if let Some((inlined, num_bytes, num_handles)) =
4405                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4406            {
4407                let member_inline_size =
4408                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4409                if inlined != (member_inline_size <= 4) {
4410                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4411                }
4412                let inner_offset;
4413                let mut inner_depth = depth.clone();
4414                if inlined {
4415                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4416                    inner_offset = next_offset;
4417                } else {
4418                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4419                    inner_depth.increment()?;
4420                }
4421                let val_ref = self.panid.get_or_insert_with(|| fidl::new_empty!(u16, D));
4422                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4423                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4424                {
4425                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4426                }
4427                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4428                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4429                }
4430            }
4431
4432            next_offset += envelope_size;
4433            _next_ordinal_to_read += 1;
4434            if next_offset >= end_offset {
4435                return Ok(());
4436            }
4437
4438            // Decode unknown envelopes for gaps in ordinals.
4439            while _next_ordinal_to_read < 6 {
4440                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4441                _next_ordinal_to_read += 1;
4442                next_offset += envelope_size;
4443            }
4444
4445            let next_out_of_line = decoder.next_out_of_line();
4446            let handles_before = decoder.remaining_handles();
4447            if let Some((inlined, num_bytes, num_handles)) =
4448                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4449            {
4450                let member_inline_size = <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4451                if inlined != (member_inline_size <= 4) {
4452                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4453                }
4454                let inner_offset;
4455                let mut inner_depth = depth.clone();
4456                if inlined {
4457                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4458                    inner_offset = next_offset;
4459                } else {
4460                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4461                    inner_depth.increment()?;
4462                }
4463                let val_ref = self.mesh_local_prefix.get_or_insert_with(|| {
4464                    fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D)
4465                });
4466                fidl::decode!(
4467                    fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
4468                    D,
4469                    val_ref,
4470                    decoder,
4471                    inner_offset,
4472                    inner_depth
4473                )?;
4474                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4475                {
4476                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4477                }
4478                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4479                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4480                }
4481            }
4482
4483            next_offset += envelope_size;
4484            _next_ordinal_to_read += 1;
4485            if next_offset >= end_offset {
4486                return Ok(());
4487            }
4488
4489            // Decode unknown envelopes for gaps in ordinals.
4490            while _next_ordinal_to_read < 7 {
4491                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4492                _next_ordinal_to_read += 1;
4493                next_offset += envelope_size;
4494            }
4495
4496            let next_out_of_line = decoder.next_out_of_line();
4497            let handles_before = decoder.remaining_handles();
4498            if let Some((inlined, num_bytes, num_handles)) =
4499                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4500            {
4501                let member_inline_size =
4502                    <fidl::encoding::Array<u8, 8> as fidl::encoding::TypeMarker>::inline_size(
4503                        decoder.context,
4504                    );
4505                if inlined != (member_inline_size <= 4) {
4506                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4507                }
4508                let inner_offset;
4509                let mut inner_depth = depth.clone();
4510                if inlined {
4511                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4512                    inner_offset = next_offset;
4513                } else {
4514                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4515                    inner_depth.increment()?;
4516                }
4517                let val_ref = self
4518                    .xpanid
4519                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 8>, D));
4520                fidl::decode!(fidl::encoding::Array<u8, 8>, D, val_ref, decoder, inner_offset, inner_depth)?;
4521                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4522                {
4523                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4524                }
4525                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4526                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4527                }
4528            }
4529
4530            next_offset += envelope_size;
4531
4532            // Decode the remaining unknown envelopes.
4533            while next_offset < end_offset {
4534                _next_ordinal_to_read += 1;
4535                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4536                next_offset += envelope_size;
4537            }
4538
4539            Ok(())
4540        }
4541    }
4542
4543    impl IpCounters {
4544        #[inline(always)]
4545        fn max_ordinal_present(&self) -> u64 {
4546            if let Some(_) = self.failure {
4547                return 2;
4548            }
4549            if let Some(_) = self.success {
4550                return 1;
4551            }
4552            0
4553        }
4554    }
4555
4556    impl fidl::encoding::ValueTypeMarker for IpCounters {
4557        type Borrowed<'a> = &'a Self;
4558        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4559            value
4560        }
4561    }
4562
4563    unsafe impl fidl::encoding::TypeMarker for IpCounters {
4564        type Owned = Self;
4565
4566        #[inline(always)]
4567        fn inline_align(_context: fidl::encoding::Context) -> usize {
4568            8
4569        }
4570
4571        #[inline(always)]
4572        fn inline_size(_context: fidl::encoding::Context) -> usize {
4573            16
4574        }
4575    }
4576
4577    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<IpCounters, D>
4578        for &IpCounters
4579    {
4580        unsafe fn encode(
4581            self,
4582            encoder: &mut fidl::encoding::Encoder<'_, D>,
4583            offset: usize,
4584            mut depth: fidl::encoding::Depth,
4585        ) -> fidl::Result<()> {
4586            encoder.debug_check_bounds::<IpCounters>(offset);
4587            // Vector header
4588            let max_ordinal: u64 = self.max_ordinal_present();
4589            encoder.write_num(max_ordinal, offset);
4590            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4591            // Calling encoder.out_of_line_offset(0) is not allowed.
4592            if max_ordinal == 0 {
4593                return Ok(());
4594            }
4595            depth.increment()?;
4596            let envelope_size = 8;
4597            let bytes_len = max_ordinal as usize * envelope_size;
4598            #[allow(unused_variables)]
4599            let offset = encoder.out_of_line_offset(bytes_len);
4600            let mut _prev_end_offset: usize = 0;
4601            if 1 > max_ordinal {
4602                return Ok(());
4603            }
4604
4605            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4606            // are envelope_size bytes.
4607            let cur_offset: usize = (1 - 1) * envelope_size;
4608
4609            // Zero reserved fields.
4610            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4611
4612            // Safety:
4613            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4614            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4615            //   envelope_size bytes, there is always sufficient room.
4616            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4617                self.success.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4618                encoder,
4619                offset + cur_offset,
4620                depth,
4621            )?;
4622
4623            _prev_end_offset = cur_offset + envelope_size;
4624            if 2 > max_ordinal {
4625                return Ok(());
4626            }
4627
4628            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4629            // are envelope_size bytes.
4630            let cur_offset: usize = (2 - 1) * envelope_size;
4631
4632            // Zero reserved fields.
4633            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4634
4635            // Safety:
4636            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4637            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4638            //   envelope_size bytes, there is always sufficient room.
4639            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4640                self.failure.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4641                encoder,
4642                offset + cur_offset,
4643                depth,
4644            )?;
4645
4646            _prev_end_offset = cur_offset + envelope_size;
4647
4648            Ok(())
4649        }
4650    }
4651
4652    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IpCounters {
4653        #[inline(always)]
4654        fn new_empty() -> Self {
4655            Self::default()
4656        }
4657
4658        unsafe fn decode(
4659            &mut self,
4660            decoder: &mut fidl::encoding::Decoder<'_, D>,
4661            offset: usize,
4662            mut depth: fidl::encoding::Depth,
4663        ) -> fidl::Result<()> {
4664            decoder.debug_check_bounds::<Self>(offset);
4665            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4666                None => return Err(fidl::Error::NotNullable),
4667                Some(len) => len,
4668            };
4669            // Calling decoder.out_of_line_offset(0) is not allowed.
4670            if len == 0 {
4671                return Ok(());
4672            };
4673            depth.increment()?;
4674            let envelope_size = 8;
4675            let bytes_len = len * envelope_size;
4676            let offset = decoder.out_of_line_offset(bytes_len)?;
4677            // Decode the envelope for each type.
4678            let mut _next_ordinal_to_read = 0;
4679            let mut next_offset = offset;
4680            let end_offset = offset + bytes_len;
4681            _next_ordinal_to_read += 1;
4682            if next_offset >= end_offset {
4683                return Ok(());
4684            }
4685
4686            // Decode unknown envelopes for gaps in ordinals.
4687            while _next_ordinal_to_read < 1 {
4688                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4689                _next_ordinal_to_read += 1;
4690                next_offset += envelope_size;
4691            }
4692
4693            let next_out_of_line = decoder.next_out_of_line();
4694            let handles_before = decoder.remaining_handles();
4695            if let Some((inlined, num_bytes, num_handles)) =
4696                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4697            {
4698                let member_inline_size =
4699                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4700                if inlined != (member_inline_size <= 4) {
4701                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4702                }
4703                let inner_offset;
4704                let mut inner_depth = depth.clone();
4705                if inlined {
4706                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4707                    inner_offset = next_offset;
4708                } else {
4709                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4710                    inner_depth.increment()?;
4711                }
4712                let val_ref = self.success.get_or_insert_with(|| fidl::new_empty!(u32, D));
4713                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4714                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4715                {
4716                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4717                }
4718                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4719                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4720                }
4721            }
4722
4723            next_offset += envelope_size;
4724            _next_ordinal_to_read += 1;
4725            if next_offset >= end_offset {
4726                return Ok(());
4727            }
4728
4729            // Decode unknown envelopes for gaps in ordinals.
4730            while _next_ordinal_to_read < 2 {
4731                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4732                _next_ordinal_to_read += 1;
4733                next_offset += envelope_size;
4734            }
4735
4736            let next_out_of_line = decoder.next_out_of_line();
4737            let handles_before = decoder.remaining_handles();
4738            if let Some((inlined, num_bytes, num_handles)) =
4739                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4740            {
4741                let member_inline_size =
4742                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4743                if inlined != (member_inline_size <= 4) {
4744                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4745                }
4746                let inner_offset;
4747                let mut inner_depth = depth.clone();
4748                if inlined {
4749                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4750                    inner_offset = next_offset;
4751                } else {
4752                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4753                    inner_depth.increment()?;
4754                }
4755                let val_ref = self.failure.get_or_insert_with(|| fidl::new_empty!(u32, D));
4756                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4757                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4758                {
4759                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4760                }
4761                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4762                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4763                }
4764            }
4765
4766            next_offset += envelope_size;
4767
4768            // Decode the remaining unknown envelopes.
4769            while next_offset < end_offset {
4770                _next_ordinal_to_read += 1;
4771                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4772                next_offset += envelope_size;
4773            }
4774
4775            Ok(())
4776        }
4777    }
4778
4779    impl MacCounters {
4780        #[inline(always)]
4781        fn max_ordinal_present(&self) -> u64 {
4782            if let Some(_) = self.err_other {
4783                return 26;
4784            }
4785            if let Some(_) = self.err_busy_channel {
4786                return 25;
4787            }
4788            if let Some(_) = self.err_abort {
4789                return 24;
4790            }
4791            if let Some(_) = self.err_cca {
4792                return 23;
4793            }
4794            if let Some(_) = self.err_fcs {
4795                return 22;
4796            }
4797            if let Some(_) = self.err_sec {
4798                return 21;
4799            }
4800            if let Some(_) = self.err_invalid_src_addr {
4801                return 20;
4802            }
4803            if let Some(_) = self.err_unknown_neighbor {
4804                return 19;
4805            }
4806            if let Some(_) = self.err_no_frame {
4807                return 18;
4808            }
4809            if let Some(_) = self.duplicated {
4810                return 17;
4811            }
4812            if let Some(_) = self.dest_addr_filtered {
4813                return 16;
4814            }
4815            if let Some(_) = self.indirect_max_retry_expiry {
4816                return 15;
4817            }
4818            if let Some(_) = self.direct_max_retry_expiry {
4819                return 14;
4820            }
4821            if let Some(_) = self.retries {
4822                return 13;
4823            }
4824            if let Some(_) = self.address_filtered {
4825                return 12;
4826            }
4827            if let Some(_) = self.other {
4828                return 11;
4829            }
4830            if let Some(_) = self.beacon_request {
4831                return 10;
4832            }
4833            if let Some(_) = self.beacon {
4834                return 9;
4835            }
4836            if let Some(_) = self.data_poll {
4837                return 8;
4838            }
4839            if let Some(_) = self.data {
4840                return 7;
4841            }
4842            if let Some(_) = self.no_ack_requested {
4843                return 6;
4844            }
4845            if let Some(_) = self.acked {
4846                return 5;
4847            }
4848            if let Some(_) = self.ack_requested {
4849                return 4;
4850            }
4851            if let Some(_) = self.broadcast {
4852                return 3;
4853            }
4854            if let Some(_) = self.unicast {
4855                return 2;
4856            }
4857            if let Some(_) = self.total {
4858                return 1;
4859            }
4860            0
4861        }
4862    }
4863
4864    impl fidl::encoding::ValueTypeMarker for MacCounters {
4865        type Borrowed<'a> = &'a Self;
4866        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4867            value
4868        }
4869    }
4870
4871    unsafe impl fidl::encoding::TypeMarker for MacCounters {
4872        type Owned = Self;
4873
4874        #[inline(always)]
4875        fn inline_align(_context: fidl::encoding::Context) -> usize {
4876            8
4877        }
4878
4879        #[inline(always)]
4880        fn inline_size(_context: fidl::encoding::Context) -> usize {
4881            16
4882        }
4883    }
4884
4885    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MacCounters, D>
4886        for &MacCounters
4887    {
4888        unsafe fn encode(
4889            self,
4890            encoder: &mut fidl::encoding::Encoder<'_, D>,
4891            offset: usize,
4892            mut depth: fidl::encoding::Depth,
4893        ) -> fidl::Result<()> {
4894            encoder.debug_check_bounds::<MacCounters>(offset);
4895            // Vector header
4896            let max_ordinal: u64 = self.max_ordinal_present();
4897            encoder.write_num(max_ordinal, offset);
4898            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4899            // Calling encoder.out_of_line_offset(0) is not allowed.
4900            if max_ordinal == 0 {
4901                return Ok(());
4902            }
4903            depth.increment()?;
4904            let envelope_size = 8;
4905            let bytes_len = max_ordinal as usize * envelope_size;
4906            #[allow(unused_variables)]
4907            let offset = encoder.out_of_line_offset(bytes_len);
4908            let mut _prev_end_offset: usize = 0;
4909            if 1 > max_ordinal {
4910                return Ok(());
4911            }
4912
4913            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4914            // are envelope_size bytes.
4915            let cur_offset: usize = (1 - 1) * envelope_size;
4916
4917            // Zero reserved fields.
4918            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4919
4920            // Safety:
4921            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4922            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4923            //   envelope_size bytes, there is always sufficient room.
4924            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4925                self.total.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4926                encoder,
4927                offset + cur_offset,
4928                depth,
4929            )?;
4930
4931            _prev_end_offset = cur_offset + envelope_size;
4932            if 2 > max_ordinal {
4933                return Ok(());
4934            }
4935
4936            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4937            // are envelope_size bytes.
4938            let cur_offset: usize = (2 - 1) * envelope_size;
4939
4940            // Zero reserved fields.
4941            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4942
4943            // Safety:
4944            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4945            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4946            //   envelope_size bytes, there is always sufficient room.
4947            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4948                self.unicast.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4949                encoder,
4950                offset + cur_offset,
4951                depth,
4952            )?;
4953
4954            _prev_end_offset = cur_offset + envelope_size;
4955            if 3 > max_ordinal {
4956                return Ok(());
4957            }
4958
4959            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4960            // are envelope_size bytes.
4961            let cur_offset: usize = (3 - 1) * envelope_size;
4962
4963            // Zero reserved fields.
4964            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4965
4966            // Safety:
4967            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4968            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4969            //   envelope_size bytes, there is always sufficient room.
4970            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4971                self.broadcast.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4972                encoder,
4973                offset + cur_offset,
4974                depth,
4975            )?;
4976
4977            _prev_end_offset = cur_offset + envelope_size;
4978            if 4 > max_ordinal {
4979                return Ok(());
4980            }
4981
4982            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4983            // are envelope_size bytes.
4984            let cur_offset: usize = (4 - 1) * envelope_size;
4985
4986            // Zero reserved fields.
4987            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4988
4989            // Safety:
4990            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4991            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4992            //   envelope_size bytes, there is always sufficient room.
4993            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4994                self.ack_requested.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4995                encoder,
4996                offset + cur_offset,
4997                depth,
4998            )?;
4999
5000            _prev_end_offset = cur_offset + envelope_size;
5001            if 5 > max_ordinal {
5002                return Ok(());
5003            }
5004
5005            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5006            // are envelope_size bytes.
5007            let cur_offset: usize = (5 - 1) * envelope_size;
5008
5009            // Zero reserved fields.
5010            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5011
5012            // Safety:
5013            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5014            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5015            //   envelope_size bytes, there is always sufficient room.
5016            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5017                self.acked.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5018                encoder,
5019                offset + cur_offset,
5020                depth,
5021            )?;
5022
5023            _prev_end_offset = cur_offset + envelope_size;
5024            if 6 > max_ordinal {
5025                return Ok(());
5026            }
5027
5028            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5029            // are envelope_size bytes.
5030            let cur_offset: usize = (6 - 1) * envelope_size;
5031
5032            // Zero reserved fields.
5033            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5034
5035            // Safety:
5036            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5037            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5038            //   envelope_size bytes, there is always sufficient room.
5039            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5040                self.no_ack_requested
5041                    .as_ref()
5042                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5043                encoder,
5044                offset + cur_offset,
5045                depth,
5046            )?;
5047
5048            _prev_end_offset = cur_offset + envelope_size;
5049            if 7 > max_ordinal {
5050                return Ok(());
5051            }
5052
5053            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5054            // are envelope_size bytes.
5055            let cur_offset: usize = (7 - 1) * envelope_size;
5056
5057            // Zero reserved fields.
5058            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5059
5060            // Safety:
5061            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5062            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5063            //   envelope_size bytes, there is always sufficient room.
5064            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5065                self.data.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5066                encoder,
5067                offset + cur_offset,
5068                depth,
5069            )?;
5070
5071            _prev_end_offset = cur_offset + envelope_size;
5072            if 8 > max_ordinal {
5073                return Ok(());
5074            }
5075
5076            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5077            // are envelope_size bytes.
5078            let cur_offset: usize = (8 - 1) * envelope_size;
5079
5080            // Zero reserved fields.
5081            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5082
5083            // Safety:
5084            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5085            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5086            //   envelope_size bytes, there is always sufficient room.
5087            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5088                self.data_poll.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5089                encoder,
5090                offset + cur_offset,
5091                depth,
5092            )?;
5093
5094            _prev_end_offset = cur_offset + envelope_size;
5095            if 9 > max_ordinal {
5096                return Ok(());
5097            }
5098
5099            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5100            // are envelope_size bytes.
5101            let cur_offset: usize = (9 - 1) * envelope_size;
5102
5103            // Zero reserved fields.
5104            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5105
5106            // Safety:
5107            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5108            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5109            //   envelope_size bytes, there is always sufficient room.
5110            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5111                self.beacon.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5112                encoder,
5113                offset + cur_offset,
5114                depth,
5115            )?;
5116
5117            _prev_end_offset = cur_offset + envelope_size;
5118            if 10 > max_ordinal {
5119                return Ok(());
5120            }
5121
5122            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5123            // are envelope_size bytes.
5124            let cur_offset: usize = (10 - 1) * envelope_size;
5125
5126            // Zero reserved fields.
5127            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5128
5129            // Safety:
5130            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5131            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5132            //   envelope_size bytes, there is always sufficient room.
5133            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5134                self.beacon_request.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5135                encoder,
5136                offset + cur_offset,
5137                depth,
5138            )?;
5139
5140            _prev_end_offset = cur_offset + envelope_size;
5141            if 11 > max_ordinal {
5142                return Ok(());
5143            }
5144
5145            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5146            // are envelope_size bytes.
5147            let cur_offset: usize = (11 - 1) * envelope_size;
5148
5149            // Zero reserved fields.
5150            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5151
5152            // Safety:
5153            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5154            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5155            //   envelope_size bytes, there is always sufficient room.
5156            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5157                self.other.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5158                encoder,
5159                offset + cur_offset,
5160                depth,
5161            )?;
5162
5163            _prev_end_offset = cur_offset + envelope_size;
5164            if 12 > max_ordinal {
5165                return Ok(());
5166            }
5167
5168            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5169            // are envelope_size bytes.
5170            let cur_offset: usize = (12 - 1) * envelope_size;
5171
5172            // Zero reserved fields.
5173            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5174
5175            // Safety:
5176            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5177            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5178            //   envelope_size bytes, there is always sufficient room.
5179            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5180                self.address_filtered
5181                    .as_ref()
5182                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5183                encoder,
5184                offset + cur_offset,
5185                depth,
5186            )?;
5187
5188            _prev_end_offset = cur_offset + envelope_size;
5189            if 13 > max_ordinal {
5190                return Ok(());
5191            }
5192
5193            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5194            // are envelope_size bytes.
5195            let cur_offset: usize = (13 - 1) * envelope_size;
5196
5197            // Zero reserved fields.
5198            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5199
5200            // Safety:
5201            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5202            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5203            //   envelope_size bytes, there is always sufficient room.
5204            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5205                self.retries.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5206                encoder,
5207                offset + cur_offset,
5208                depth,
5209            )?;
5210
5211            _prev_end_offset = cur_offset + envelope_size;
5212            if 14 > max_ordinal {
5213                return Ok(());
5214            }
5215
5216            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5217            // are envelope_size bytes.
5218            let cur_offset: usize = (14 - 1) * envelope_size;
5219
5220            // Zero reserved fields.
5221            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5222
5223            // Safety:
5224            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5225            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5226            //   envelope_size bytes, there is always sufficient room.
5227            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5228                self.direct_max_retry_expiry
5229                    .as_ref()
5230                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5231                encoder,
5232                offset + cur_offset,
5233                depth,
5234            )?;
5235
5236            _prev_end_offset = cur_offset + envelope_size;
5237            if 15 > max_ordinal {
5238                return Ok(());
5239            }
5240
5241            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5242            // are envelope_size bytes.
5243            let cur_offset: usize = (15 - 1) * envelope_size;
5244
5245            // Zero reserved fields.
5246            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5247
5248            // Safety:
5249            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5250            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5251            //   envelope_size bytes, there is always sufficient room.
5252            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5253                self.indirect_max_retry_expiry
5254                    .as_ref()
5255                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5256                encoder,
5257                offset + cur_offset,
5258                depth,
5259            )?;
5260
5261            _prev_end_offset = cur_offset + envelope_size;
5262            if 16 > max_ordinal {
5263                return Ok(());
5264            }
5265
5266            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5267            // are envelope_size bytes.
5268            let cur_offset: usize = (16 - 1) * envelope_size;
5269
5270            // Zero reserved fields.
5271            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5272
5273            // Safety:
5274            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5275            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5276            //   envelope_size bytes, there is always sufficient room.
5277            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5278                self.dest_addr_filtered
5279                    .as_ref()
5280                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5281                encoder,
5282                offset + cur_offset,
5283                depth,
5284            )?;
5285
5286            _prev_end_offset = cur_offset + envelope_size;
5287            if 17 > max_ordinal {
5288                return Ok(());
5289            }
5290
5291            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5292            // are envelope_size bytes.
5293            let cur_offset: usize = (17 - 1) * envelope_size;
5294
5295            // Zero reserved fields.
5296            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5297
5298            // Safety:
5299            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5300            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5301            //   envelope_size bytes, there is always sufficient room.
5302            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5303                self.duplicated.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5304                encoder,
5305                offset + cur_offset,
5306                depth,
5307            )?;
5308
5309            _prev_end_offset = cur_offset + envelope_size;
5310            if 18 > max_ordinal {
5311                return Ok(());
5312            }
5313
5314            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5315            // are envelope_size bytes.
5316            let cur_offset: usize = (18 - 1) * envelope_size;
5317
5318            // Zero reserved fields.
5319            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5320
5321            // Safety:
5322            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5323            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5324            //   envelope_size bytes, there is always sufficient room.
5325            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5326                self.err_no_frame.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5327                encoder,
5328                offset + cur_offset,
5329                depth,
5330            )?;
5331
5332            _prev_end_offset = cur_offset + envelope_size;
5333            if 19 > max_ordinal {
5334                return Ok(());
5335            }
5336
5337            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5338            // are envelope_size bytes.
5339            let cur_offset: usize = (19 - 1) * envelope_size;
5340
5341            // Zero reserved fields.
5342            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5343
5344            // Safety:
5345            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5346            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5347            //   envelope_size bytes, there is always sufficient room.
5348            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5349                self.err_unknown_neighbor
5350                    .as_ref()
5351                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5352                encoder,
5353                offset + cur_offset,
5354                depth,
5355            )?;
5356
5357            _prev_end_offset = cur_offset + envelope_size;
5358            if 20 > max_ordinal {
5359                return Ok(());
5360            }
5361
5362            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5363            // are envelope_size bytes.
5364            let cur_offset: usize = (20 - 1) * envelope_size;
5365
5366            // Zero reserved fields.
5367            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5368
5369            // Safety:
5370            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5371            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5372            //   envelope_size bytes, there is always sufficient room.
5373            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5374                self.err_invalid_src_addr
5375                    .as_ref()
5376                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5377                encoder,
5378                offset + cur_offset,
5379                depth,
5380            )?;
5381
5382            _prev_end_offset = cur_offset + envelope_size;
5383            if 21 > max_ordinal {
5384                return Ok(());
5385            }
5386
5387            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5388            // are envelope_size bytes.
5389            let cur_offset: usize = (21 - 1) * envelope_size;
5390
5391            // Zero reserved fields.
5392            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5393
5394            // Safety:
5395            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5396            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5397            //   envelope_size bytes, there is always sufficient room.
5398            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5399                self.err_sec.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5400                encoder,
5401                offset + cur_offset,
5402                depth,
5403            )?;
5404
5405            _prev_end_offset = cur_offset + envelope_size;
5406            if 22 > max_ordinal {
5407                return Ok(());
5408            }
5409
5410            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5411            // are envelope_size bytes.
5412            let cur_offset: usize = (22 - 1) * envelope_size;
5413
5414            // Zero reserved fields.
5415            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5416
5417            // Safety:
5418            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5419            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5420            //   envelope_size bytes, there is always sufficient room.
5421            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5422                self.err_fcs.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5423                encoder,
5424                offset + cur_offset,
5425                depth,
5426            )?;
5427
5428            _prev_end_offset = cur_offset + envelope_size;
5429            if 23 > max_ordinal {
5430                return Ok(());
5431            }
5432
5433            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5434            // are envelope_size bytes.
5435            let cur_offset: usize = (23 - 1) * envelope_size;
5436
5437            // Zero reserved fields.
5438            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5439
5440            // Safety:
5441            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5442            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5443            //   envelope_size bytes, there is always sufficient room.
5444            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5445                self.err_cca.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5446                encoder,
5447                offset + cur_offset,
5448                depth,
5449            )?;
5450
5451            _prev_end_offset = cur_offset + envelope_size;
5452            if 24 > max_ordinal {
5453                return Ok(());
5454            }
5455
5456            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5457            // are envelope_size bytes.
5458            let cur_offset: usize = (24 - 1) * envelope_size;
5459
5460            // Zero reserved fields.
5461            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5462
5463            // Safety:
5464            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5465            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5466            //   envelope_size bytes, there is always sufficient room.
5467            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5468                self.err_abort.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5469                encoder,
5470                offset + cur_offset,
5471                depth,
5472            )?;
5473
5474            _prev_end_offset = cur_offset + envelope_size;
5475            if 25 > max_ordinal {
5476                return Ok(());
5477            }
5478
5479            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5480            // are envelope_size bytes.
5481            let cur_offset: usize = (25 - 1) * envelope_size;
5482
5483            // Zero reserved fields.
5484            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5485
5486            // Safety:
5487            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5488            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5489            //   envelope_size bytes, there is always sufficient room.
5490            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5491                self.err_busy_channel
5492                    .as_ref()
5493                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5494                encoder,
5495                offset + cur_offset,
5496                depth,
5497            )?;
5498
5499            _prev_end_offset = cur_offset + envelope_size;
5500            if 26 > max_ordinal {
5501                return Ok(());
5502            }
5503
5504            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5505            // are envelope_size bytes.
5506            let cur_offset: usize = (26 - 1) * envelope_size;
5507
5508            // Zero reserved fields.
5509            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5510
5511            // Safety:
5512            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5513            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5514            //   envelope_size bytes, there is always sufficient room.
5515            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5516                self.err_other.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5517                encoder,
5518                offset + cur_offset,
5519                depth,
5520            )?;
5521
5522            _prev_end_offset = cur_offset + envelope_size;
5523
5524            Ok(())
5525        }
5526    }
5527
5528    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MacCounters {
5529        #[inline(always)]
5530        fn new_empty() -> Self {
5531            Self::default()
5532        }
5533
5534        unsafe fn decode(
5535            &mut self,
5536            decoder: &mut fidl::encoding::Decoder<'_, D>,
5537            offset: usize,
5538            mut depth: fidl::encoding::Depth,
5539        ) -> fidl::Result<()> {
5540            decoder.debug_check_bounds::<Self>(offset);
5541            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5542                None => return Err(fidl::Error::NotNullable),
5543                Some(len) => len,
5544            };
5545            // Calling decoder.out_of_line_offset(0) is not allowed.
5546            if len == 0 {
5547                return Ok(());
5548            };
5549            depth.increment()?;
5550            let envelope_size = 8;
5551            let bytes_len = len * envelope_size;
5552            let offset = decoder.out_of_line_offset(bytes_len)?;
5553            // Decode the envelope for each type.
5554            let mut _next_ordinal_to_read = 0;
5555            let mut next_offset = offset;
5556            let end_offset = offset + bytes_len;
5557            _next_ordinal_to_read += 1;
5558            if next_offset >= end_offset {
5559                return Ok(());
5560            }
5561
5562            // Decode unknown envelopes for gaps in ordinals.
5563            while _next_ordinal_to_read < 1 {
5564                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5565                _next_ordinal_to_read += 1;
5566                next_offset += envelope_size;
5567            }
5568
5569            let next_out_of_line = decoder.next_out_of_line();
5570            let handles_before = decoder.remaining_handles();
5571            if let Some((inlined, num_bytes, num_handles)) =
5572                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5573            {
5574                let member_inline_size =
5575                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5576                if inlined != (member_inline_size <= 4) {
5577                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5578                }
5579                let inner_offset;
5580                let mut inner_depth = depth.clone();
5581                if inlined {
5582                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5583                    inner_offset = next_offset;
5584                } else {
5585                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5586                    inner_depth.increment()?;
5587                }
5588                let val_ref = self.total.get_or_insert_with(|| fidl::new_empty!(u32, D));
5589                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5590                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5591                {
5592                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5593                }
5594                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5595                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5596                }
5597            }
5598
5599            next_offset += envelope_size;
5600            _next_ordinal_to_read += 1;
5601            if next_offset >= end_offset {
5602                return Ok(());
5603            }
5604
5605            // Decode unknown envelopes for gaps in ordinals.
5606            while _next_ordinal_to_read < 2 {
5607                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5608                _next_ordinal_to_read += 1;
5609                next_offset += envelope_size;
5610            }
5611
5612            let next_out_of_line = decoder.next_out_of_line();
5613            let handles_before = decoder.remaining_handles();
5614            if let Some((inlined, num_bytes, num_handles)) =
5615                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5616            {
5617                let member_inline_size =
5618                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5619                if inlined != (member_inline_size <= 4) {
5620                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5621                }
5622                let inner_offset;
5623                let mut inner_depth = depth.clone();
5624                if inlined {
5625                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5626                    inner_offset = next_offset;
5627                } else {
5628                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5629                    inner_depth.increment()?;
5630                }
5631                let val_ref = self.unicast.get_or_insert_with(|| fidl::new_empty!(u32, D));
5632                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5633                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5634                {
5635                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5636                }
5637                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5638                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5639                }
5640            }
5641
5642            next_offset += envelope_size;
5643            _next_ordinal_to_read += 1;
5644            if next_offset >= end_offset {
5645                return Ok(());
5646            }
5647
5648            // Decode unknown envelopes for gaps in ordinals.
5649            while _next_ordinal_to_read < 3 {
5650                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5651                _next_ordinal_to_read += 1;
5652                next_offset += envelope_size;
5653            }
5654
5655            let next_out_of_line = decoder.next_out_of_line();
5656            let handles_before = decoder.remaining_handles();
5657            if let Some((inlined, num_bytes, num_handles)) =
5658                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5659            {
5660                let member_inline_size =
5661                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5662                if inlined != (member_inline_size <= 4) {
5663                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5664                }
5665                let inner_offset;
5666                let mut inner_depth = depth.clone();
5667                if inlined {
5668                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5669                    inner_offset = next_offset;
5670                } else {
5671                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5672                    inner_depth.increment()?;
5673                }
5674                let val_ref = self.broadcast.get_or_insert_with(|| fidl::new_empty!(u32, D));
5675                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5676                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5677                {
5678                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5679                }
5680                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5681                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5682                }
5683            }
5684
5685            next_offset += envelope_size;
5686            _next_ordinal_to_read += 1;
5687            if next_offset >= end_offset {
5688                return Ok(());
5689            }
5690
5691            // Decode unknown envelopes for gaps in ordinals.
5692            while _next_ordinal_to_read < 4 {
5693                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5694                _next_ordinal_to_read += 1;
5695                next_offset += envelope_size;
5696            }
5697
5698            let next_out_of_line = decoder.next_out_of_line();
5699            let handles_before = decoder.remaining_handles();
5700            if let Some((inlined, num_bytes, num_handles)) =
5701                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5702            {
5703                let member_inline_size =
5704                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5705                if inlined != (member_inline_size <= 4) {
5706                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5707                }
5708                let inner_offset;
5709                let mut inner_depth = depth.clone();
5710                if inlined {
5711                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5712                    inner_offset = next_offset;
5713                } else {
5714                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5715                    inner_depth.increment()?;
5716                }
5717                let val_ref = self.ack_requested.get_or_insert_with(|| fidl::new_empty!(u32, D));
5718                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5719                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5720                {
5721                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5722                }
5723                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5724                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5725                }
5726            }
5727
5728            next_offset += envelope_size;
5729            _next_ordinal_to_read += 1;
5730            if next_offset >= end_offset {
5731                return Ok(());
5732            }
5733
5734            // Decode unknown envelopes for gaps in ordinals.
5735            while _next_ordinal_to_read < 5 {
5736                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5737                _next_ordinal_to_read += 1;
5738                next_offset += envelope_size;
5739            }
5740
5741            let next_out_of_line = decoder.next_out_of_line();
5742            let handles_before = decoder.remaining_handles();
5743            if let Some((inlined, num_bytes, num_handles)) =
5744                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5745            {
5746                let member_inline_size =
5747                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5748                if inlined != (member_inline_size <= 4) {
5749                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5750                }
5751                let inner_offset;
5752                let mut inner_depth = depth.clone();
5753                if inlined {
5754                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5755                    inner_offset = next_offset;
5756                } else {
5757                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5758                    inner_depth.increment()?;
5759                }
5760                let val_ref = self.acked.get_or_insert_with(|| fidl::new_empty!(u32, D));
5761                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5762                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5763                {
5764                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5765                }
5766                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5767                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5768                }
5769            }
5770
5771            next_offset += envelope_size;
5772            _next_ordinal_to_read += 1;
5773            if next_offset >= end_offset {
5774                return Ok(());
5775            }
5776
5777            // Decode unknown envelopes for gaps in ordinals.
5778            while _next_ordinal_to_read < 6 {
5779                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5780                _next_ordinal_to_read += 1;
5781                next_offset += envelope_size;
5782            }
5783
5784            let next_out_of_line = decoder.next_out_of_line();
5785            let handles_before = decoder.remaining_handles();
5786            if let Some((inlined, num_bytes, num_handles)) =
5787                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5788            {
5789                let member_inline_size =
5790                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5791                if inlined != (member_inline_size <= 4) {
5792                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5793                }
5794                let inner_offset;
5795                let mut inner_depth = depth.clone();
5796                if inlined {
5797                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5798                    inner_offset = next_offset;
5799                } else {
5800                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5801                    inner_depth.increment()?;
5802                }
5803                let val_ref = self.no_ack_requested.get_or_insert_with(|| fidl::new_empty!(u32, D));
5804                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5805                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5806                {
5807                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5808                }
5809                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5810                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5811                }
5812            }
5813
5814            next_offset += envelope_size;
5815            _next_ordinal_to_read += 1;
5816            if next_offset >= end_offset {
5817                return Ok(());
5818            }
5819
5820            // Decode unknown envelopes for gaps in ordinals.
5821            while _next_ordinal_to_read < 7 {
5822                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5823                _next_ordinal_to_read += 1;
5824                next_offset += envelope_size;
5825            }
5826
5827            let next_out_of_line = decoder.next_out_of_line();
5828            let handles_before = decoder.remaining_handles();
5829            if let Some((inlined, num_bytes, num_handles)) =
5830                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5831            {
5832                let member_inline_size =
5833                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5834                if inlined != (member_inline_size <= 4) {
5835                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5836                }
5837                let inner_offset;
5838                let mut inner_depth = depth.clone();
5839                if inlined {
5840                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5841                    inner_offset = next_offset;
5842                } else {
5843                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5844                    inner_depth.increment()?;
5845                }
5846                let val_ref = self.data.get_or_insert_with(|| fidl::new_empty!(u32, D));
5847                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5848                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5849                {
5850                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5851                }
5852                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5853                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5854                }
5855            }
5856
5857            next_offset += envelope_size;
5858            _next_ordinal_to_read += 1;
5859            if next_offset >= end_offset {
5860                return Ok(());
5861            }
5862
5863            // Decode unknown envelopes for gaps in ordinals.
5864            while _next_ordinal_to_read < 8 {
5865                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5866                _next_ordinal_to_read += 1;
5867                next_offset += envelope_size;
5868            }
5869
5870            let next_out_of_line = decoder.next_out_of_line();
5871            let handles_before = decoder.remaining_handles();
5872            if let Some((inlined, num_bytes, num_handles)) =
5873                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5874            {
5875                let member_inline_size =
5876                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5877                if inlined != (member_inline_size <= 4) {
5878                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5879                }
5880                let inner_offset;
5881                let mut inner_depth = depth.clone();
5882                if inlined {
5883                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5884                    inner_offset = next_offset;
5885                } else {
5886                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5887                    inner_depth.increment()?;
5888                }
5889                let val_ref = self.data_poll.get_or_insert_with(|| fidl::new_empty!(u32, D));
5890                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5891                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5892                {
5893                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5894                }
5895                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5896                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5897                }
5898            }
5899
5900            next_offset += envelope_size;
5901            _next_ordinal_to_read += 1;
5902            if next_offset >= end_offset {
5903                return Ok(());
5904            }
5905
5906            // Decode unknown envelopes for gaps in ordinals.
5907            while _next_ordinal_to_read < 9 {
5908                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5909                _next_ordinal_to_read += 1;
5910                next_offset += envelope_size;
5911            }
5912
5913            let next_out_of_line = decoder.next_out_of_line();
5914            let handles_before = decoder.remaining_handles();
5915            if let Some((inlined, num_bytes, num_handles)) =
5916                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5917            {
5918                let member_inline_size =
5919                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5920                if inlined != (member_inline_size <= 4) {
5921                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5922                }
5923                let inner_offset;
5924                let mut inner_depth = depth.clone();
5925                if inlined {
5926                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5927                    inner_offset = next_offset;
5928                } else {
5929                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5930                    inner_depth.increment()?;
5931                }
5932                let val_ref = self.beacon.get_or_insert_with(|| fidl::new_empty!(u32, D));
5933                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5934                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5935                {
5936                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5937                }
5938                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5939                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5940                }
5941            }
5942
5943            next_offset += envelope_size;
5944            _next_ordinal_to_read += 1;
5945            if next_offset >= end_offset {
5946                return Ok(());
5947            }
5948
5949            // Decode unknown envelopes for gaps in ordinals.
5950            while _next_ordinal_to_read < 10 {
5951                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5952                _next_ordinal_to_read += 1;
5953                next_offset += envelope_size;
5954            }
5955
5956            let next_out_of_line = decoder.next_out_of_line();
5957            let handles_before = decoder.remaining_handles();
5958            if let Some((inlined, num_bytes, num_handles)) =
5959                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5960            {
5961                let member_inline_size =
5962                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5963                if inlined != (member_inline_size <= 4) {
5964                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5965                }
5966                let inner_offset;
5967                let mut inner_depth = depth.clone();
5968                if inlined {
5969                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5970                    inner_offset = next_offset;
5971                } else {
5972                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5973                    inner_depth.increment()?;
5974                }
5975                let val_ref = self.beacon_request.get_or_insert_with(|| fidl::new_empty!(u32, D));
5976                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5977                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5978                {
5979                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5980                }
5981                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5982                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5983                }
5984            }
5985
5986            next_offset += envelope_size;
5987            _next_ordinal_to_read += 1;
5988            if next_offset >= end_offset {
5989                return Ok(());
5990            }
5991
5992            // Decode unknown envelopes for gaps in ordinals.
5993            while _next_ordinal_to_read < 11 {
5994                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5995                _next_ordinal_to_read += 1;
5996                next_offset += envelope_size;
5997            }
5998
5999            let next_out_of_line = decoder.next_out_of_line();
6000            let handles_before = decoder.remaining_handles();
6001            if let Some((inlined, num_bytes, num_handles)) =
6002                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6003            {
6004                let member_inline_size =
6005                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6006                if inlined != (member_inline_size <= 4) {
6007                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6008                }
6009                let inner_offset;
6010                let mut inner_depth = depth.clone();
6011                if inlined {
6012                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6013                    inner_offset = next_offset;
6014                } else {
6015                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6016                    inner_depth.increment()?;
6017                }
6018                let val_ref = self.other.get_or_insert_with(|| fidl::new_empty!(u32, D));
6019                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6020                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6021                {
6022                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6023                }
6024                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6025                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6026                }
6027            }
6028
6029            next_offset += envelope_size;
6030            _next_ordinal_to_read += 1;
6031            if next_offset >= end_offset {
6032                return Ok(());
6033            }
6034
6035            // Decode unknown envelopes for gaps in ordinals.
6036            while _next_ordinal_to_read < 12 {
6037                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6038                _next_ordinal_to_read += 1;
6039                next_offset += envelope_size;
6040            }
6041
6042            let next_out_of_line = decoder.next_out_of_line();
6043            let handles_before = decoder.remaining_handles();
6044            if let Some((inlined, num_bytes, num_handles)) =
6045                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6046            {
6047                let member_inline_size =
6048                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6049                if inlined != (member_inline_size <= 4) {
6050                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6051                }
6052                let inner_offset;
6053                let mut inner_depth = depth.clone();
6054                if inlined {
6055                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6056                    inner_offset = next_offset;
6057                } else {
6058                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6059                    inner_depth.increment()?;
6060                }
6061                let val_ref = self.address_filtered.get_or_insert_with(|| fidl::new_empty!(u32, D));
6062                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6063                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6064                {
6065                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6066                }
6067                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6068                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6069                }
6070            }
6071
6072            next_offset += envelope_size;
6073            _next_ordinal_to_read += 1;
6074            if next_offset >= end_offset {
6075                return Ok(());
6076            }
6077
6078            // Decode unknown envelopes for gaps in ordinals.
6079            while _next_ordinal_to_read < 13 {
6080                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6081                _next_ordinal_to_read += 1;
6082                next_offset += envelope_size;
6083            }
6084
6085            let next_out_of_line = decoder.next_out_of_line();
6086            let handles_before = decoder.remaining_handles();
6087            if let Some((inlined, num_bytes, num_handles)) =
6088                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6089            {
6090                let member_inline_size =
6091                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6092                if inlined != (member_inline_size <= 4) {
6093                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6094                }
6095                let inner_offset;
6096                let mut inner_depth = depth.clone();
6097                if inlined {
6098                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6099                    inner_offset = next_offset;
6100                } else {
6101                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6102                    inner_depth.increment()?;
6103                }
6104                let val_ref = self.retries.get_or_insert_with(|| fidl::new_empty!(u32, D));
6105                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6106                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6107                {
6108                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6109                }
6110                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6111                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6112                }
6113            }
6114
6115            next_offset += envelope_size;
6116            _next_ordinal_to_read += 1;
6117            if next_offset >= end_offset {
6118                return Ok(());
6119            }
6120
6121            // Decode unknown envelopes for gaps in ordinals.
6122            while _next_ordinal_to_read < 14 {
6123                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6124                _next_ordinal_to_read += 1;
6125                next_offset += envelope_size;
6126            }
6127
6128            let next_out_of_line = decoder.next_out_of_line();
6129            let handles_before = decoder.remaining_handles();
6130            if let Some((inlined, num_bytes, num_handles)) =
6131                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6132            {
6133                let member_inline_size =
6134                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6135                if inlined != (member_inline_size <= 4) {
6136                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6137                }
6138                let inner_offset;
6139                let mut inner_depth = depth.clone();
6140                if inlined {
6141                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6142                    inner_offset = next_offset;
6143                } else {
6144                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6145                    inner_depth.increment()?;
6146                }
6147                let val_ref =
6148                    self.direct_max_retry_expiry.get_or_insert_with(|| fidl::new_empty!(u32, D));
6149                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6150                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6151                {
6152                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6153                }
6154                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6155                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6156                }
6157            }
6158
6159            next_offset += envelope_size;
6160            _next_ordinal_to_read += 1;
6161            if next_offset >= end_offset {
6162                return Ok(());
6163            }
6164
6165            // Decode unknown envelopes for gaps in ordinals.
6166            while _next_ordinal_to_read < 15 {
6167                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6168                _next_ordinal_to_read += 1;
6169                next_offset += envelope_size;
6170            }
6171
6172            let next_out_of_line = decoder.next_out_of_line();
6173            let handles_before = decoder.remaining_handles();
6174            if let Some((inlined, num_bytes, num_handles)) =
6175                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6176            {
6177                let member_inline_size =
6178                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6179                if inlined != (member_inline_size <= 4) {
6180                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6181                }
6182                let inner_offset;
6183                let mut inner_depth = depth.clone();
6184                if inlined {
6185                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6186                    inner_offset = next_offset;
6187                } else {
6188                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6189                    inner_depth.increment()?;
6190                }
6191                let val_ref =
6192                    self.indirect_max_retry_expiry.get_or_insert_with(|| fidl::new_empty!(u32, D));
6193                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6194                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6195                {
6196                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6197                }
6198                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6199                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6200                }
6201            }
6202
6203            next_offset += envelope_size;
6204            _next_ordinal_to_read += 1;
6205            if next_offset >= end_offset {
6206                return Ok(());
6207            }
6208
6209            // Decode unknown envelopes for gaps in ordinals.
6210            while _next_ordinal_to_read < 16 {
6211                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6212                _next_ordinal_to_read += 1;
6213                next_offset += envelope_size;
6214            }
6215
6216            let next_out_of_line = decoder.next_out_of_line();
6217            let handles_before = decoder.remaining_handles();
6218            if let Some((inlined, num_bytes, num_handles)) =
6219                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6220            {
6221                let member_inline_size =
6222                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6223                if inlined != (member_inline_size <= 4) {
6224                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6225                }
6226                let inner_offset;
6227                let mut inner_depth = depth.clone();
6228                if inlined {
6229                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6230                    inner_offset = next_offset;
6231                } else {
6232                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6233                    inner_depth.increment()?;
6234                }
6235                let val_ref =
6236                    self.dest_addr_filtered.get_or_insert_with(|| fidl::new_empty!(u32, D));
6237                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6238                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6239                {
6240                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6241                }
6242                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6243                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6244                }
6245            }
6246
6247            next_offset += envelope_size;
6248            _next_ordinal_to_read += 1;
6249            if next_offset >= end_offset {
6250                return Ok(());
6251            }
6252
6253            // Decode unknown envelopes for gaps in ordinals.
6254            while _next_ordinal_to_read < 17 {
6255                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6256                _next_ordinal_to_read += 1;
6257                next_offset += envelope_size;
6258            }
6259
6260            let next_out_of_line = decoder.next_out_of_line();
6261            let handles_before = decoder.remaining_handles();
6262            if let Some((inlined, num_bytes, num_handles)) =
6263                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6264            {
6265                let member_inline_size =
6266                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6267                if inlined != (member_inline_size <= 4) {
6268                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6269                }
6270                let inner_offset;
6271                let mut inner_depth = depth.clone();
6272                if inlined {
6273                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6274                    inner_offset = next_offset;
6275                } else {
6276                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6277                    inner_depth.increment()?;
6278                }
6279                let val_ref = self.duplicated.get_or_insert_with(|| fidl::new_empty!(u32, D));
6280                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6281                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6282                {
6283                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6284                }
6285                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6286                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6287                }
6288            }
6289
6290            next_offset += envelope_size;
6291            _next_ordinal_to_read += 1;
6292            if next_offset >= end_offset {
6293                return Ok(());
6294            }
6295
6296            // Decode unknown envelopes for gaps in ordinals.
6297            while _next_ordinal_to_read < 18 {
6298                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6299                _next_ordinal_to_read += 1;
6300                next_offset += envelope_size;
6301            }
6302
6303            let next_out_of_line = decoder.next_out_of_line();
6304            let handles_before = decoder.remaining_handles();
6305            if let Some((inlined, num_bytes, num_handles)) =
6306                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6307            {
6308                let member_inline_size =
6309                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6310                if inlined != (member_inline_size <= 4) {
6311                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6312                }
6313                let inner_offset;
6314                let mut inner_depth = depth.clone();
6315                if inlined {
6316                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6317                    inner_offset = next_offset;
6318                } else {
6319                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6320                    inner_depth.increment()?;
6321                }
6322                let val_ref = self.err_no_frame.get_or_insert_with(|| fidl::new_empty!(u32, D));
6323                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6324                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6325                {
6326                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6327                }
6328                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6329                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6330                }
6331            }
6332
6333            next_offset += envelope_size;
6334            _next_ordinal_to_read += 1;
6335            if next_offset >= end_offset {
6336                return Ok(());
6337            }
6338
6339            // Decode unknown envelopes for gaps in ordinals.
6340            while _next_ordinal_to_read < 19 {
6341                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6342                _next_ordinal_to_read += 1;
6343                next_offset += envelope_size;
6344            }
6345
6346            let next_out_of_line = decoder.next_out_of_line();
6347            let handles_before = decoder.remaining_handles();
6348            if let Some((inlined, num_bytes, num_handles)) =
6349                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6350            {
6351                let member_inline_size =
6352                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6353                if inlined != (member_inline_size <= 4) {
6354                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6355                }
6356                let inner_offset;
6357                let mut inner_depth = depth.clone();
6358                if inlined {
6359                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6360                    inner_offset = next_offset;
6361                } else {
6362                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6363                    inner_depth.increment()?;
6364                }
6365                let val_ref =
6366                    self.err_unknown_neighbor.get_or_insert_with(|| fidl::new_empty!(u32, D));
6367                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6368                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6369                {
6370                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6371                }
6372                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6373                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6374                }
6375            }
6376
6377            next_offset += envelope_size;
6378            _next_ordinal_to_read += 1;
6379            if next_offset >= end_offset {
6380                return Ok(());
6381            }
6382
6383            // Decode unknown envelopes for gaps in ordinals.
6384            while _next_ordinal_to_read < 20 {
6385                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6386                _next_ordinal_to_read += 1;
6387                next_offset += envelope_size;
6388            }
6389
6390            let next_out_of_line = decoder.next_out_of_line();
6391            let handles_before = decoder.remaining_handles();
6392            if let Some((inlined, num_bytes, num_handles)) =
6393                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6394            {
6395                let member_inline_size =
6396                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6397                if inlined != (member_inline_size <= 4) {
6398                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6399                }
6400                let inner_offset;
6401                let mut inner_depth = depth.clone();
6402                if inlined {
6403                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6404                    inner_offset = next_offset;
6405                } else {
6406                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6407                    inner_depth.increment()?;
6408                }
6409                let val_ref =
6410                    self.err_invalid_src_addr.get_or_insert_with(|| fidl::new_empty!(u32, D));
6411                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6412                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6413                {
6414                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6415                }
6416                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6417                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6418                }
6419            }
6420
6421            next_offset += envelope_size;
6422            _next_ordinal_to_read += 1;
6423            if next_offset >= end_offset {
6424                return Ok(());
6425            }
6426
6427            // Decode unknown envelopes for gaps in ordinals.
6428            while _next_ordinal_to_read < 21 {
6429                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6430                _next_ordinal_to_read += 1;
6431                next_offset += envelope_size;
6432            }
6433
6434            let next_out_of_line = decoder.next_out_of_line();
6435            let handles_before = decoder.remaining_handles();
6436            if let Some((inlined, num_bytes, num_handles)) =
6437                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6438            {
6439                let member_inline_size =
6440                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6441                if inlined != (member_inline_size <= 4) {
6442                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6443                }
6444                let inner_offset;
6445                let mut inner_depth = depth.clone();
6446                if inlined {
6447                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6448                    inner_offset = next_offset;
6449                } else {
6450                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6451                    inner_depth.increment()?;
6452                }
6453                let val_ref = self.err_sec.get_or_insert_with(|| fidl::new_empty!(u32, D));
6454                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6455                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6456                {
6457                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6458                }
6459                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6460                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6461                }
6462            }
6463
6464            next_offset += envelope_size;
6465            _next_ordinal_to_read += 1;
6466            if next_offset >= end_offset {
6467                return Ok(());
6468            }
6469
6470            // Decode unknown envelopes for gaps in ordinals.
6471            while _next_ordinal_to_read < 22 {
6472                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6473                _next_ordinal_to_read += 1;
6474                next_offset += envelope_size;
6475            }
6476
6477            let next_out_of_line = decoder.next_out_of_line();
6478            let handles_before = decoder.remaining_handles();
6479            if let Some((inlined, num_bytes, num_handles)) =
6480                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6481            {
6482                let member_inline_size =
6483                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6484                if inlined != (member_inline_size <= 4) {
6485                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6486                }
6487                let inner_offset;
6488                let mut inner_depth = depth.clone();
6489                if inlined {
6490                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6491                    inner_offset = next_offset;
6492                } else {
6493                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6494                    inner_depth.increment()?;
6495                }
6496                let val_ref = self.err_fcs.get_or_insert_with(|| fidl::new_empty!(u32, D));
6497                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6498                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6499                {
6500                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6501                }
6502                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6503                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6504                }
6505            }
6506
6507            next_offset += envelope_size;
6508            _next_ordinal_to_read += 1;
6509            if next_offset >= end_offset {
6510                return Ok(());
6511            }
6512
6513            // Decode unknown envelopes for gaps in ordinals.
6514            while _next_ordinal_to_read < 23 {
6515                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6516                _next_ordinal_to_read += 1;
6517                next_offset += envelope_size;
6518            }
6519
6520            let next_out_of_line = decoder.next_out_of_line();
6521            let handles_before = decoder.remaining_handles();
6522            if let Some((inlined, num_bytes, num_handles)) =
6523                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6524            {
6525                let member_inline_size =
6526                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6527                if inlined != (member_inline_size <= 4) {
6528                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6529                }
6530                let inner_offset;
6531                let mut inner_depth = depth.clone();
6532                if inlined {
6533                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6534                    inner_offset = next_offset;
6535                } else {
6536                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6537                    inner_depth.increment()?;
6538                }
6539                let val_ref = self.err_cca.get_or_insert_with(|| fidl::new_empty!(u32, D));
6540                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6541                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6542                {
6543                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6544                }
6545                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6546                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6547                }
6548            }
6549
6550            next_offset += envelope_size;
6551            _next_ordinal_to_read += 1;
6552            if next_offset >= end_offset {
6553                return Ok(());
6554            }
6555
6556            // Decode unknown envelopes for gaps in ordinals.
6557            while _next_ordinal_to_read < 24 {
6558                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6559                _next_ordinal_to_read += 1;
6560                next_offset += envelope_size;
6561            }
6562
6563            let next_out_of_line = decoder.next_out_of_line();
6564            let handles_before = decoder.remaining_handles();
6565            if let Some((inlined, num_bytes, num_handles)) =
6566                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6567            {
6568                let member_inline_size =
6569                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6570                if inlined != (member_inline_size <= 4) {
6571                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6572                }
6573                let inner_offset;
6574                let mut inner_depth = depth.clone();
6575                if inlined {
6576                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6577                    inner_offset = next_offset;
6578                } else {
6579                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6580                    inner_depth.increment()?;
6581                }
6582                let val_ref = self.err_abort.get_or_insert_with(|| fidl::new_empty!(u32, D));
6583                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6584                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6585                {
6586                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6587                }
6588                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6589                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6590                }
6591            }
6592
6593            next_offset += envelope_size;
6594            _next_ordinal_to_read += 1;
6595            if next_offset >= end_offset {
6596                return Ok(());
6597            }
6598
6599            // Decode unknown envelopes for gaps in ordinals.
6600            while _next_ordinal_to_read < 25 {
6601                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6602                _next_ordinal_to_read += 1;
6603                next_offset += envelope_size;
6604            }
6605
6606            let next_out_of_line = decoder.next_out_of_line();
6607            let handles_before = decoder.remaining_handles();
6608            if let Some((inlined, num_bytes, num_handles)) =
6609                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6610            {
6611                let member_inline_size =
6612                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6613                if inlined != (member_inline_size <= 4) {
6614                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6615                }
6616                let inner_offset;
6617                let mut inner_depth = depth.clone();
6618                if inlined {
6619                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6620                    inner_offset = next_offset;
6621                } else {
6622                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6623                    inner_depth.increment()?;
6624                }
6625                let val_ref = self.err_busy_channel.get_or_insert_with(|| fidl::new_empty!(u32, D));
6626                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6627                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6628                {
6629                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6630                }
6631                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6632                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6633                }
6634            }
6635
6636            next_offset += envelope_size;
6637            _next_ordinal_to_read += 1;
6638            if next_offset >= end_offset {
6639                return Ok(());
6640            }
6641
6642            // Decode unknown envelopes for gaps in ordinals.
6643            while _next_ordinal_to_read < 26 {
6644                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6645                _next_ordinal_to_read += 1;
6646                next_offset += envelope_size;
6647            }
6648
6649            let next_out_of_line = decoder.next_out_of_line();
6650            let handles_before = decoder.remaining_handles();
6651            if let Some((inlined, num_bytes, num_handles)) =
6652                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6653            {
6654                let member_inline_size =
6655                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6656                if inlined != (member_inline_size <= 4) {
6657                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6658                }
6659                let inner_offset;
6660                let mut inner_depth = depth.clone();
6661                if inlined {
6662                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6663                    inner_offset = next_offset;
6664                } else {
6665                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6666                    inner_depth.increment()?;
6667                }
6668                let val_ref = self.err_other.get_or_insert_with(|| fidl::new_empty!(u32, D));
6669                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6670                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6671                {
6672                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6673                }
6674                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6675                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6676                }
6677            }
6678
6679            next_offset += envelope_size;
6680
6681            // Decode the remaining unknown envelopes.
6682            while next_offset < end_offset {
6683                _next_ordinal_to_read += 1;
6684                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6685                next_offset += envelope_size;
6686            }
6687
6688            Ok(())
6689        }
6690    }
6691
6692    impl fidl::encoding::ValueTypeMarker for Credential {
6693        type Borrowed<'a> = &'a Self;
6694        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6695            value
6696        }
6697    }
6698
6699    unsafe impl fidl::encoding::TypeMarker for Credential {
6700        type Owned = Self;
6701
6702        #[inline(always)]
6703        fn inline_align(_context: fidl::encoding::Context) -> usize {
6704            8
6705        }
6706
6707        #[inline(always)]
6708        fn inline_size(_context: fidl::encoding::Context) -> usize {
6709            16
6710        }
6711    }
6712
6713    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Credential, D>
6714        for &Credential
6715    {
6716        #[inline]
6717        unsafe fn encode(
6718            self,
6719            encoder: &mut fidl::encoding::Encoder<'_, D>,
6720            offset: usize,
6721            _depth: fidl::encoding::Depth,
6722        ) -> fidl::Result<()> {
6723            encoder.debug_check_bounds::<Credential>(offset);
6724            encoder.write_num::<u64>(self.ordinal(), offset);
6725            match self {
6726                Credential::NetworkKey(ref val) => {
6727                    fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<u8, 32>, D>(
6728                        <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow(
6729                            val,
6730                        ),
6731                        encoder,
6732                        offset + 8,
6733                        _depth,
6734                    )
6735                }
6736                Credential::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
6737            }
6738        }
6739    }
6740
6741    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Credential {
6742        #[inline(always)]
6743        fn new_empty() -> Self {
6744            Self::__SourceBreaking { unknown_ordinal: 0 }
6745        }
6746
6747        #[inline]
6748        unsafe fn decode(
6749            &mut self,
6750            decoder: &mut fidl::encoding::Decoder<'_, D>,
6751            offset: usize,
6752            mut depth: fidl::encoding::Depth,
6753        ) -> fidl::Result<()> {
6754            decoder.debug_check_bounds::<Self>(offset);
6755            #[allow(unused_variables)]
6756            let next_out_of_line = decoder.next_out_of_line();
6757            let handles_before = decoder.remaining_handles();
6758            let (ordinal, inlined, num_bytes, num_handles) =
6759                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
6760
6761            let member_inline_size = match ordinal {
6762                1 => <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
6763                    decoder.context,
6764                ),
6765                0 => return Err(fidl::Error::UnknownUnionTag),
6766                _ => num_bytes as usize,
6767            };
6768
6769            if inlined != (member_inline_size <= 4) {
6770                return Err(fidl::Error::InvalidInlineBitInEnvelope);
6771            }
6772            let _inner_offset;
6773            if inlined {
6774                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
6775                _inner_offset = offset + 8;
6776            } else {
6777                depth.increment()?;
6778                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6779            }
6780            match ordinal {
6781                1 => {
6782                    #[allow(irrefutable_let_patterns)]
6783                    if let Credential::NetworkKey(_) = self {
6784                        // Do nothing, read the value into the object
6785                    } else {
6786                        // Initialize `self` to the right variant
6787                        *self = Credential::NetworkKey(
6788                            fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D),
6789                        );
6790                    }
6791                    #[allow(irrefutable_let_patterns)]
6792                    if let Credential::NetworkKey(ref mut val) = self {
6793                        fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val, decoder, _inner_offset, depth)?;
6794                    } else {
6795                        unreachable!()
6796                    }
6797                }
6798                #[allow(deprecated)]
6799                ordinal => {
6800                    for _ in 0..num_handles {
6801                        decoder.drop_next_handle()?;
6802                    }
6803                    *self = Credential::__SourceBreaking { unknown_ordinal: ordinal };
6804                }
6805            }
6806            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
6807                return Err(fidl::Error::InvalidNumBytesInEnvelope);
6808            }
6809            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6810                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6811            }
6812            Ok(())
6813        }
6814    }
6815}