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
752mod internal {
753    use super::*;
754    unsafe impl fidl::encoding::TypeMarker for ConnectivityState {
755        type Owned = Self;
756
757        #[inline(always)]
758        fn inline_align(_context: fidl::encoding::Context) -> usize {
759            std::mem::align_of::<i32>()
760        }
761
762        #[inline(always)]
763        fn inline_size(_context: fidl::encoding::Context) -> usize {
764            std::mem::size_of::<i32>()
765        }
766
767        #[inline(always)]
768        fn encode_is_copy() -> bool {
769            false
770        }
771
772        #[inline(always)]
773        fn decode_is_copy() -> bool {
774            false
775        }
776    }
777
778    impl fidl::encoding::ValueTypeMarker for ConnectivityState {
779        type Borrowed<'a> = Self;
780        #[inline(always)]
781        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
782            *value
783        }
784    }
785
786    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
787        for ConnectivityState
788    {
789        #[inline]
790        unsafe fn encode(
791            self,
792            encoder: &mut fidl::encoding::Encoder<'_, D>,
793            offset: usize,
794            _depth: fidl::encoding::Depth,
795        ) -> fidl::Result<()> {
796            encoder.debug_check_bounds::<Self>(offset);
797            encoder.write_num(self.into_primitive(), offset);
798            Ok(())
799        }
800    }
801
802    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConnectivityState {
803        #[inline(always)]
804        fn new_empty() -> Self {
805            Self::unknown()
806        }
807
808        #[inline]
809        unsafe fn decode(
810            &mut self,
811            decoder: &mut fidl::encoding::Decoder<'_, D>,
812            offset: usize,
813            _depth: fidl::encoding::Depth,
814        ) -> fidl::Result<()> {
815            decoder.debug_check_bounds::<Self>(offset);
816            let prim = decoder.read_num::<i32>(offset);
817
818            *self = Self::from_primitive_allow_unknown(prim);
819            Ok(())
820        }
821    }
822    unsafe impl fidl::encoding::TypeMarker for Role {
823        type Owned = Self;
824
825        #[inline(always)]
826        fn inline_align(_context: fidl::encoding::Context) -> usize {
827            std::mem::align_of::<i32>()
828        }
829
830        #[inline(always)]
831        fn inline_size(_context: fidl::encoding::Context) -> usize {
832            std::mem::size_of::<i32>()
833        }
834
835        #[inline(always)]
836        fn encode_is_copy() -> bool {
837            false
838        }
839
840        #[inline(always)]
841        fn decode_is_copy() -> bool {
842            false
843        }
844    }
845
846    impl fidl::encoding::ValueTypeMarker for Role {
847        type Borrowed<'a> = Self;
848        #[inline(always)]
849        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
850            *value
851        }
852    }
853
854    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Role {
855        #[inline]
856        unsafe fn encode(
857            self,
858            encoder: &mut fidl::encoding::Encoder<'_, D>,
859            offset: usize,
860            _depth: fidl::encoding::Depth,
861        ) -> fidl::Result<()> {
862            encoder.debug_check_bounds::<Self>(offset);
863            encoder.write_num(self.into_primitive(), offset);
864            Ok(())
865        }
866    }
867
868    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Role {
869        #[inline(always)]
870        fn new_empty() -> Self {
871            Self::unknown()
872        }
873
874        #[inline]
875        unsafe fn decode(
876            &mut self,
877            decoder: &mut fidl::encoding::Decoder<'_, D>,
878            offset: usize,
879            _depth: fidl::encoding::Depth,
880        ) -> fidl::Result<()> {
881            decoder.debug_check_bounds::<Self>(offset);
882            let prim = decoder.read_num::<i32>(offset);
883
884            *self = Self::from_primitive_allow_unknown(prim);
885            Ok(())
886        }
887    }
888
889    impl fidl::encoding::ValueTypeMarker for CountersGetResponse {
890        type Borrowed<'a> = &'a Self;
891        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
892            value
893        }
894    }
895
896    unsafe impl fidl::encoding::TypeMarker for CountersGetResponse {
897        type Owned = Self;
898
899        #[inline(always)]
900        fn inline_align(_context: fidl::encoding::Context) -> usize {
901            8
902        }
903
904        #[inline(always)]
905        fn inline_size(_context: fidl::encoding::Context) -> usize {
906            16
907        }
908    }
909
910    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CountersGetResponse, D>
911        for &CountersGetResponse
912    {
913        #[inline]
914        unsafe fn encode(
915            self,
916            encoder: &mut fidl::encoding::Encoder<'_, D>,
917            offset: usize,
918            _depth: fidl::encoding::Depth,
919        ) -> fidl::Result<()> {
920            encoder.debug_check_bounds::<CountersGetResponse>(offset);
921            // Delegate to tuple encoding.
922            fidl::encoding::Encode::<CountersGetResponse, D>::encode(
923                (<AllCounters as fidl::encoding::ValueTypeMarker>::borrow(&self.counters),),
924                encoder,
925                offset,
926                _depth,
927            )
928        }
929    }
930    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AllCounters, D>>
931        fidl::encoding::Encode<CountersGetResponse, D> for (T0,)
932    {
933        #[inline]
934        unsafe fn encode(
935            self,
936            encoder: &mut fidl::encoding::Encoder<'_, D>,
937            offset: usize,
938            depth: fidl::encoding::Depth,
939        ) -> fidl::Result<()> {
940            encoder.debug_check_bounds::<CountersGetResponse>(offset);
941            // Zero out padding regions. There's no need to apply masks
942            // because the unmasked parts will be overwritten by fields.
943            // Write the fields.
944            self.0.encode(encoder, offset + 0, depth)?;
945            Ok(())
946        }
947    }
948
949    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CountersGetResponse {
950        #[inline(always)]
951        fn new_empty() -> Self {
952            Self { counters: fidl::new_empty!(AllCounters, D) }
953        }
954
955        #[inline]
956        unsafe fn decode(
957            &mut self,
958            decoder: &mut fidl::encoding::Decoder<'_, D>,
959            offset: usize,
960            _depth: fidl::encoding::Depth,
961        ) -> fidl::Result<()> {
962            decoder.debug_check_bounds::<Self>(offset);
963            // Verify that padding bytes are zero.
964            fidl::decode!(AllCounters, D, &mut self.counters, decoder, offset + 0, _depth)?;
965            Ok(())
966        }
967    }
968
969    impl fidl::encoding::ValueTypeMarker for CountersResetResponse {
970        type Borrowed<'a> = &'a Self;
971        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
972            value
973        }
974    }
975
976    unsafe impl fidl::encoding::TypeMarker for CountersResetResponse {
977        type Owned = Self;
978
979        #[inline(always)]
980        fn inline_align(_context: fidl::encoding::Context) -> usize {
981            8
982        }
983
984        #[inline(always)]
985        fn inline_size(_context: fidl::encoding::Context) -> usize {
986            16
987        }
988    }
989
990    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CountersResetResponse, D>
991        for &CountersResetResponse
992    {
993        #[inline]
994        unsafe fn encode(
995            self,
996            encoder: &mut fidl::encoding::Encoder<'_, D>,
997            offset: usize,
998            _depth: fidl::encoding::Depth,
999        ) -> fidl::Result<()> {
1000            encoder.debug_check_bounds::<CountersResetResponse>(offset);
1001            // Delegate to tuple encoding.
1002            fidl::encoding::Encode::<CountersResetResponse, D>::encode(
1003                (<AllCounters as fidl::encoding::ValueTypeMarker>::borrow(&self.counters),),
1004                encoder,
1005                offset,
1006                _depth,
1007            )
1008        }
1009    }
1010    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AllCounters, D>>
1011        fidl::encoding::Encode<CountersResetResponse, D> for (T0,)
1012    {
1013        #[inline]
1014        unsafe fn encode(
1015            self,
1016            encoder: &mut fidl::encoding::Encoder<'_, D>,
1017            offset: usize,
1018            depth: fidl::encoding::Depth,
1019        ) -> fidl::Result<()> {
1020            encoder.debug_check_bounds::<CountersResetResponse>(offset);
1021            // Zero out padding regions. There's no need to apply masks
1022            // because the unmasked parts will be overwritten by fields.
1023            // Write the fields.
1024            self.0.encode(encoder, offset + 0, depth)?;
1025            Ok(())
1026        }
1027    }
1028
1029    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CountersResetResponse {
1030        #[inline(always)]
1031        fn new_empty() -> Self {
1032            Self { counters: fidl::new_empty!(AllCounters, D) }
1033        }
1034
1035        #[inline]
1036        unsafe fn decode(
1037            &mut self,
1038            decoder: &mut fidl::encoding::Decoder<'_, D>,
1039            offset: usize,
1040            _depth: fidl::encoding::Depth,
1041        ) -> fidl::Result<()> {
1042            decoder.debug_check_bounds::<Self>(offset);
1043            // Verify that padding bytes are zero.
1044            fidl::decode!(AllCounters, D, &mut self.counters, decoder, offset + 0, _depth)?;
1045            Ok(())
1046        }
1047    }
1048
1049    impl fidl::encoding::ValueTypeMarker for DeviceExtraGetCredentialResponse {
1050        type Borrowed<'a> = &'a Self;
1051        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1052            value
1053        }
1054    }
1055
1056    unsafe impl fidl::encoding::TypeMarker for DeviceExtraGetCredentialResponse {
1057        type Owned = Self;
1058
1059        #[inline(always)]
1060        fn inline_align(_context: fidl::encoding::Context) -> usize {
1061            8
1062        }
1063
1064        #[inline(always)]
1065        fn inline_size(_context: fidl::encoding::Context) -> usize {
1066            16
1067        }
1068    }
1069
1070    unsafe impl<D: fidl::encoding::ResourceDialect>
1071        fidl::encoding::Encode<DeviceExtraGetCredentialResponse, D>
1072        for &DeviceExtraGetCredentialResponse
1073    {
1074        #[inline]
1075        unsafe fn encode(
1076            self,
1077            encoder: &mut fidl::encoding::Encoder<'_, D>,
1078            offset: usize,
1079            _depth: fidl::encoding::Depth,
1080        ) -> fidl::Result<()> {
1081            encoder.debug_check_bounds::<DeviceExtraGetCredentialResponse>(offset);
1082            // Delegate to tuple encoding.
1083            fidl::encoding::Encode::<DeviceExtraGetCredentialResponse, D>::encode(
1084                (
1085                    <fidl::encoding::OptionalUnion<Credential> as fidl::encoding::ValueTypeMarker>::borrow(&self.credential),
1086                ),
1087                encoder, offset, _depth
1088            )
1089        }
1090    }
1091    unsafe impl<
1092            D: fidl::encoding::ResourceDialect,
1093            T0: fidl::encoding::Encode<fidl::encoding::OptionalUnion<Credential>, D>,
1094        > fidl::encoding::Encode<DeviceExtraGetCredentialResponse, D> for (T0,)
1095    {
1096        #[inline]
1097        unsafe fn encode(
1098            self,
1099            encoder: &mut fidl::encoding::Encoder<'_, D>,
1100            offset: usize,
1101            depth: fidl::encoding::Depth,
1102        ) -> fidl::Result<()> {
1103            encoder.debug_check_bounds::<DeviceExtraGetCredentialResponse>(offset);
1104            // Zero out padding regions. There's no need to apply masks
1105            // because the unmasked parts will be overwritten by fields.
1106            // Write the fields.
1107            self.0.encode(encoder, offset + 0, depth)?;
1108            Ok(())
1109        }
1110    }
1111
1112    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1113        for DeviceExtraGetCredentialResponse
1114    {
1115        #[inline(always)]
1116        fn new_empty() -> Self {
1117            Self { credential: fidl::new_empty!(fidl::encoding::OptionalUnion<Credential>, D) }
1118        }
1119
1120        #[inline]
1121        unsafe fn decode(
1122            &mut self,
1123            decoder: &mut fidl::encoding::Decoder<'_, D>,
1124            offset: usize,
1125            _depth: fidl::encoding::Depth,
1126        ) -> fidl::Result<()> {
1127            decoder.debug_check_bounds::<Self>(offset);
1128            // Verify that padding bytes are zero.
1129            fidl::decode!(
1130                fidl::encoding::OptionalUnion<Credential>,
1131                D,
1132                &mut self.credential,
1133                decoder,
1134                offset + 0,
1135                _depth
1136            )?;
1137            Ok(())
1138        }
1139    }
1140
1141    impl fidl::encoding::ValueTypeMarker for DeviceExtraGetCurrentMacAddressResponse {
1142        type Borrowed<'a> = &'a Self;
1143        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1144            value
1145        }
1146    }
1147
1148    unsafe impl fidl::encoding::TypeMarker for DeviceExtraGetCurrentMacAddressResponse {
1149        type Owned = Self;
1150
1151        #[inline(always)]
1152        fn inline_align(_context: fidl::encoding::Context) -> usize {
1153            1
1154        }
1155
1156        #[inline(always)]
1157        fn inline_size(_context: fidl::encoding::Context) -> usize {
1158            8
1159        }
1160    }
1161
1162    unsafe impl<D: fidl::encoding::ResourceDialect>
1163        fidl::encoding::Encode<DeviceExtraGetCurrentMacAddressResponse, D>
1164        for &DeviceExtraGetCurrentMacAddressResponse
1165    {
1166        #[inline]
1167        unsafe fn encode(
1168            self,
1169            encoder: &mut fidl::encoding::Encoder<'_, D>,
1170            offset: usize,
1171            _depth: fidl::encoding::Depth,
1172        ) -> fidl::Result<()> {
1173            encoder.debug_check_bounds::<DeviceExtraGetCurrentMacAddressResponse>(offset);
1174            // Delegate to tuple encoding.
1175            fidl::encoding::Encode::<DeviceExtraGetCurrentMacAddressResponse, D>::encode(
1176                (
1177                    <fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow(&self.address),
1178                ),
1179                encoder, offset, _depth
1180            )
1181        }
1182    }
1183    unsafe impl<
1184            D: fidl::encoding::ResourceDialect,
1185            T0: fidl::encoding::Encode<fidl_fuchsia_lowpan__common::MacAddress, D>,
1186        > fidl::encoding::Encode<DeviceExtraGetCurrentMacAddressResponse, D> for (T0,)
1187    {
1188        #[inline]
1189        unsafe fn encode(
1190            self,
1191            encoder: &mut fidl::encoding::Encoder<'_, D>,
1192            offset: usize,
1193            depth: fidl::encoding::Depth,
1194        ) -> fidl::Result<()> {
1195            encoder.debug_check_bounds::<DeviceExtraGetCurrentMacAddressResponse>(offset);
1196            // Zero out padding regions. There's no need to apply masks
1197            // because the unmasked parts will be overwritten by fields.
1198            // Write the fields.
1199            self.0.encode(encoder, offset + 0, depth)?;
1200            Ok(())
1201        }
1202    }
1203
1204    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1205        for DeviceExtraGetCurrentMacAddressResponse
1206    {
1207        #[inline(always)]
1208        fn new_empty() -> Self {
1209            Self { address: fidl::new_empty!(fidl_fuchsia_lowpan__common::MacAddress, D) }
1210        }
1211
1212        #[inline]
1213        unsafe fn decode(
1214            &mut self,
1215            decoder: &mut fidl::encoding::Decoder<'_, D>,
1216            offset: usize,
1217            _depth: fidl::encoding::Depth,
1218        ) -> fidl::Result<()> {
1219            decoder.debug_check_bounds::<Self>(offset);
1220            // Verify that padding bytes are zero.
1221            fidl::decode!(
1222                fidl_fuchsia_lowpan__common::MacAddress,
1223                D,
1224                &mut self.address,
1225                decoder,
1226                offset + 0,
1227                _depth
1228            )?;
1229            Ok(())
1230        }
1231    }
1232
1233    impl fidl::encoding::ValueTypeMarker for DeviceExtraWatchIdentityResponse {
1234        type Borrowed<'a> = &'a Self;
1235        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1236            value
1237        }
1238    }
1239
1240    unsafe impl fidl::encoding::TypeMarker for DeviceExtraWatchIdentityResponse {
1241        type Owned = Self;
1242
1243        #[inline(always)]
1244        fn inline_align(_context: fidl::encoding::Context) -> usize {
1245            8
1246        }
1247
1248        #[inline(always)]
1249        fn inline_size(_context: fidl::encoding::Context) -> usize {
1250            16
1251        }
1252    }
1253
1254    unsafe impl<D: fidl::encoding::ResourceDialect>
1255        fidl::encoding::Encode<DeviceExtraWatchIdentityResponse, D>
1256        for &DeviceExtraWatchIdentityResponse
1257    {
1258        #[inline]
1259        unsafe fn encode(
1260            self,
1261            encoder: &mut fidl::encoding::Encoder<'_, D>,
1262            offset: usize,
1263            _depth: fidl::encoding::Depth,
1264        ) -> fidl::Result<()> {
1265            encoder.debug_check_bounds::<DeviceExtraWatchIdentityResponse>(offset);
1266            // Delegate to tuple encoding.
1267            fidl::encoding::Encode::<DeviceExtraWatchIdentityResponse, D>::encode(
1268                (<Identity as fidl::encoding::ValueTypeMarker>::borrow(&self.identity),),
1269                encoder,
1270                offset,
1271                _depth,
1272            )
1273        }
1274    }
1275    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Identity, D>>
1276        fidl::encoding::Encode<DeviceExtraWatchIdentityResponse, D> for (T0,)
1277    {
1278        #[inline]
1279        unsafe fn encode(
1280            self,
1281            encoder: &mut fidl::encoding::Encoder<'_, D>,
1282            offset: usize,
1283            depth: fidl::encoding::Depth,
1284        ) -> fidl::Result<()> {
1285            encoder.debug_check_bounds::<DeviceExtraWatchIdentityResponse>(offset);
1286            // Zero out padding regions. There's no need to apply masks
1287            // because the unmasked parts will be overwritten by fields.
1288            // Write the fields.
1289            self.0.encode(encoder, offset + 0, depth)?;
1290            Ok(())
1291        }
1292    }
1293
1294    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1295        for DeviceExtraWatchIdentityResponse
1296    {
1297        #[inline(always)]
1298        fn new_empty() -> Self {
1299            Self { identity: fidl::new_empty!(Identity, D) }
1300        }
1301
1302        #[inline]
1303        unsafe fn decode(
1304            &mut self,
1305            decoder: &mut fidl::encoding::Decoder<'_, D>,
1306            offset: usize,
1307            _depth: fidl::encoding::Depth,
1308        ) -> fidl::Result<()> {
1309            decoder.debug_check_bounds::<Self>(offset);
1310            // Verify that padding bytes are zero.
1311            fidl::decode!(Identity, D, &mut self.identity, decoder, offset + 0, _depth)?;
1312            Ok(())
1313        }
1314    }
1315
1316    impl fidl::encoding::ValueTypeMarker for DeviceGetSupportedNetworkTypesResponse {
1317        type Borrowed<'a> = &'a Self;
1318        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1319            value
1320        }
1321    }
1322
1323    unsafe impl fidl::encoding::TypeMarker for DeviceGetSupportedNetworkTypesResponse {
1324        type Owned = Self;
1325
1326        #[inline(always)]
1327        fn inline_align(_context: fidl::encoding::Context) -> usize {
1328            8
1329        }
1330
1331        #[inline(always)]
1332        fn inline_size(_context: fidl::encoding::Context) -> usize {
1333            16
1334        }
1335    }
1336
1337    unsafe impl<D: fidl::encoding::ResourceDialect>
1338        fidl::encoding::Encode<DeviceGetSupportedNetworkTypesResponse, D>
1339        for &DeviceGetSupportedNetworkTypesResponse
1340    {
1341        #[inline]
1342        unsafe fn encode(
1343            self,
1344            encoder: &mut fidl::encoding::Encoder<'_, D>,
1345            offset: usize,
1346            _depth: fidl::encoding::Depth,
1347        ) -> fidl::Result<()> {
1348            encoder.debug_check_bounds::<DeviceGetSupportedNetworkTypesResponse>(offset);
1349            // Delegate to tuple encoding.
1350            fidl::encoding::Encode::<DeviceGetSupportedNetworkTypesResponse, D>::encode(
1351                (
1352                    <fidl::encoding::Vector<fidl::encoding::BoundedString<64>, 16> as fidl::encoding::ValueTypeMarker>::borrow(&self.network_types),
1353                ),
1354                encoder, offset, _depth
1355            )
1356        }
1357    }
1358    unsafe impl<
1359            D: fidl::encoding::ResourceDialect,
1360            T0: fidl::encoding::Encode<
1361                fidl::encoding::Vector<fidl::encoding::BoundedString<64>, 16>,
1362                D,
1363            >,
1364        > fidl::encoding::Encode<DeviceGetSupportedNetworkTypesResponse, D> for (T0,)
1365    {
1366        #[inline]
1367        unsafe fn encode(
1368            self,
1369            encoder: &mut fidl::encoding::Encoder<'_, D>,
1370            offset: usize,
1371            depth: fidl::encoding::Depth,
1372        ) -> fidl::Result<()> {
1373            encoder.debug_check_bounds::<DeviceGetSupportedNetworkTypesResponse>(offset);
1374            // Zero out padding regions. There's no need to apply masks
1375            // because the unmasked parts will be overwritten by fields.
1376            // Write the fields.
1377            self.0.encode(encoder, offset + 0, depth)?;
1378            Ok(())
1379        }
1380    }
1381
1382    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1383        for DeviceGetSupportedNetworkTypesResponse
1384    {
1385        #[inline(always)]
1386        fn new_empty() -> Self {
1387            Self {
1388                network_types: fidl::new_empty!(
1389                    fidl::encoding::Vector<fidl::encoding::BoundedString<64>, 16>,
1390                    D
1391                ),
1392            }
1393        }
1394
1395        #[inline]
1396        unsafe fn decode(
1397            &mut self,
1398            decoder: &mut fidl::encoding::Decoder<'_, D>,
1399            offset: usize,
1400            _depth: fidl::encoding::Depth,
1401        ) -> fidl::Result<()> {
1402            decoder.debug_check_bounds::<Self>(offset);
1403            // Verify that padding bytes are zero.
1404            fidl::decode!(
1405                fidl::encoding::Vector<fidl::encoding::BoundedString<64>, 16>,
1406                D,
1407                &mut self.network_types,
1408                decoder,
1409                offset + 0,
1410                _depth
1411            )?;
1412            Ok(())
1413        }
1414    }
1415
1416    impl fidl::encoding::ValueTypeMarker for DeviceProvisionNetworkRequest {
1417        type Borrowed<'a> = &'a Self;
1418        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1419            value
1420        }
1421    }
1422
1423    unsafe impl fidl::encoding::TypeMarker for DeviceProvisionNetworkRequest {
1424        type Owned = Self;
1425
1426        #[inline(always)]
1427        fn inline_align(_context: fidl::encoding::Context) -> usize {
1428            8
1429        }
1430
1431        #[inline(always)]
1432        fn inline_size(_context: fidl::encoding::Context) -> usize {
1433            32
1434        }
1435    }
1436
1437    unsafe impl<D: fidl::encoding::ResourceDialect>
1438        fidl::encoding::Encode<DeviceProvisionNetworkRequest, D>
1439        for &DeviceProvisionNetworkRequest
1440    {
1441        #[inline]
1442        unsafe fn encode(
1443            self,
1444            encoder: &mut fidl::encoding::Encoder<'_, D>,
1445            offset: usize,
1446            _depth: fidl::encoding::Depth,
1447        ) -> fidl::Result<()> {
1448            encoder.debug_check_bounds::<DeviceProvisionNetworkRequest>(offset);
1449            // Delegate to tuple encoding.
1450            fidl::encoding::Encode::<DeviceProvisionNetworkRequest, D>::encode(
1451                (<ProvisioningParams as fidl::encoding::ValueTypeMarker>::borrow(&self.params),),
1452                encoder,
1453                offset,
1454                _depth,
1455            )
1456        }
1457    }
1458    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ProvisioningParams, D>>
1459        fidl::encoding::Encode<DeviceProvisionNetworkRequest, D> for (T0,)
1460    {
1461        #[inline]
1462        unsafe fn encode(
1463            self,
1464            encoder: &mut fidl::encoding::Encoder<'_, D>,
1465            offset: usize,
1466            depth: fidl::encoding::Depth,
1467        ) -> fidl::Result<()> {
1468            encoder.debug_check_bounds::<DeviceProvisionNetworkRequest>(offset);
1469            // Zero out padding regions. There's no need to apply masks
1470            // because the unmasked parts will be overwritten by fields.
1471            // Write the fields.
1472            self.0.encode(encoder, offset + 0, depth)?;
1473            Ok(())
1474        }
1475    }
1476
1477    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1478        for DeviceProvisionNetworkRequest
1479    {
1480        #[inline(always)]
1481        fn new_empty() -> Self {
1482            Self { params: fidl::new_empty!(ProvisioningParams, D) }
1483        }
1484
1485        #[inline]
1486        unsafe fn decode(
1487            &mut self,
1488            decoder: &mut fidl::encoding::Decoder<'_, D>,
1489            offset: usize,
1490            _depth: fidl::encoding::Depth,
1491        ) -> fidl::Result<()> {
1492            decoder.debug_check_bounds::<Self>(offset);
1493            // Verify that padding bytes are zero.
1494            fidl::decode!(ProvisioningParams, D, &mut self.params, decoder, offset + 0, _depth)?;
1495            Ok(())
1496        }
1497    }
1498
1499    impl fidl::encoding::ValueTypeMarker for DeviceSetActiveRequest {
1500        type Borrowed<'a> = &'a Self;
1501        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1502            value
1503        }
1504    }
1505
1506    unsafe impl fidl::encoding::TypeMarker for DeviceSetActiveRequest {
1507        type Owned = Self;
1508
1509        #[inline(always)]
1510        fn inline_align(_context: fidl::encoding::Context) -> usize {
1511            1
1512        }
1513
1514        #[inline(always)]
1515        fn inline_size(_context: fidl::encoding::Context) -> usize {
1516            1
1517        }
1518    }
1519
1520    unsafe impl<D: fidl::encoding::ResourceDialect>
1521        fidl::encoding::Encode<DeviceSetActiveRequest, D> for &DeviceSetActiveRequest
1522    {
1523        #[inline]
1524        unsafe fn encode(
1525            self,
1526            encoder: &mut fidl::encoding::Encoder<'_, D>,
1527            offset: usize,
1528            _depth: fidl::encoding::Depth,
1529        ) -> fidl::Result<()> {
1530            encoder.debug_check_bounds::<DeviceSetActiveRequest>(offset);
1531            // Delegate to tuple encoding.
1532            fidl::encoding::Encode::<DeviceSetActiveRequest, D>::encode(
1533                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.active),),
1534                encoder,
1535                offset,
1536                _depth,
1537            )
1538        }
1539    }
1540    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
1541        fidl::encoding::Encode<DeviceSetActiveRequest, D> for (T0,)
1542    {
1543        #[inline]
1544        unsafe fn encode(
1545            self,
1546            encoder: &mut fidl::encoding::Encoder<'_, D>,
1547            offset: usize,
1548            depth: fidl::encoding::Depth,
1549        ) -> fidl::Result<()> {
1550            encoder.debug_check_bounds::<DeviceSetActiveRequest>(offset);
1551            // Zero out padding regions. There's no need to apply masks
1552            // because the unmasked parts will be overwritten by fields.
1553            // Write the fields.
1554            self.0.encode(encoder, offset + 0, depth)?;
1555            Ok(())
1556        }
1557    }
1558
1559    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1560        for DeviceSetActiveRequest
1561    {
1562        #[inline(always)]
1563        fn new_empty() -> Self {
1564            Self { active: fidl::new_empty!(bool, D) }
1565        }
1566
1567        #[inline]
1568        unsafe fn decode(
1569            &mut self,
1570            decoder: &mut fidl::encoding::Decoder<'_, D>,
1571            offset: usize,
1572            _depth: fidl::encoding::Depth,
1573        ) -> fidl::Result<()> {
1574            decoder.debug_check_bounds::<Self>(offset);
1575            // Verify that padding bytes are zero.
1576            fidl::decode!(bool, D, &mut self.active, decoder, offset + 0, _depth)?;
1577            Ok(())
1578        }
1579    }
1580
1581    impl fidl::encoding::ValueTypeMarker for DeviceWatchDeviceStateResponse {
1582        type Borrowed<'a> = &'a Self;
1583        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1584            value
1585        }
1586    }
1587
1588    unsafe impl fidl::encoding::TypeMarker for DeviceWatchDeviceStateResponse {
1589        type Owned = Self;
1590
1591        #[inline(always)]
1592        fn inline_align(_context: fidl::encoding::Context) -> usize {
1593            8
1594        }
1595
1596        #[inline(always)]
1597        fn inline_size(_context: fidl::encoding::Context) -> usize {
1598            16
1599        }
1600    }
1601
1602    unsafe impl<D: fidl::encoding::ResourceDialect>
1603        fidl::encoding::Encode<DeviceWatchDeviceStateResponse, D>
1604        for &DeviceWatchDeviceStateResponse
1605    {
1606        #[inline]
1607        unsafe fn encode(
1608            self,
1609            encoder: &mut fidl::encoding::Encoder<'_, D>,
1610            offset: usize,
1611            _depth: fidl::encoding::Depth,
1612        ) -> fidl::Result<()> {
1613            encoder.debug_check_bounds::<DeviceWatchDeviceStateResponse>(offset);
1614            // Delegate to tuple encoding.
1615            fidl::encoding::Encode::<DeviceWatchDeviceStateResponse, D>::encode(
1616                (<DeviceState as fidl::encoding::ValueTypeMarker>::borrow(
1617                    &self.device_combined_state,
1618                ),),
1619                encoder,
1620                offset,
1621                _depth,
1622            )
1623        }
1624    }
1625    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<DeviceState, D>>
1626        fidl::encoding::Encode<DeviceWatchDeviceStateResponse, D> for (T0,)
1627    {
1628        #[inline]
1629        unsafe fn encode(
1630            self,
1631            encoder: &mut fidl::encoding::Encoder<'_, D>,
1632            offset: usize,
1633            depth: fidl::encoding::Depth,
1634        ) -> fidl::Result<()> {
1635            encoder.debug_check_bounds::<DeviceWatchDeviceStateResponse>(offset);
1636            // Zero out padding regions. There's no need to apply masks
1637            // because the unmasked parts will be overwritten by fields.
1638            // Write the fields.
1639            self.0.encode(encoder, offset + 0, depth)?;
1640            Ok(())
1641        }
1642    }
1643
1644    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1645        for DeviceWatchDeviceStateResponse
1646    {
1647        #[inline(always)]
1648        fn new_empty() -> Self {
1649            Self { device_combined_state: fidl::new_empty!(DeviceState, D) }
1650        }
1651
1652        #[inline]
1653        unsafe fn decode(
1654            &mut self,
1655            decoder: &mut fidl::encoding::Decoder<'_, D>,
1656            offset: usize,
1657            _depth: fidl::encoding::Depth,
1658        ) -> fidl::Result<()> {
1659            decoder.debug_check_bounds::<Self>(offset);
1660            // Verify that padding bytes are zero.
1661            fidl::decode!(
1662                DeviceState,
1663                D,
1664                &mut self.device_combined_state,
1665                decoder,
1666                offset + 0,
1667                _depth
1668            )?;
1669            Ok(())
1670        }
1671    }
1672
1673    impl fidl::encoding::ValueTypeMarker for EnergyScanResultStreamNextResponse {
1674        type Borrowed<'a> = &'a Self;
1675        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1676            value
1677        }
1678    }
1679
1680    unsafe impl fidl::encoding::TypeMarker for EnergyScanResultStreamNextResponse {
1681        type Owned = Self;
1682
1683        #[inline(always)]
1684        fn inline_align(_context: fidl::encoding::Context) -> usize {
1685            8
1686        }
1687
1688        #[inline(always)]
1689        fn inline_size(_context: fidl::encoding::Context) -> usize {
1690            16
1691        }
1692    }
1693
1694    unsafe impl<D: fidl::encoding::ResourceDialect>
1695        fidl::encoding::Encode<EnergyScanResultStreamNextResponse, D>
1696        for &EnergyScanResultStreamNextResponse
1697    {
1698        #[inline]
1699        unsafe fn encode(
1700            self,
1701            encoder: &mut fidl::encoding::Encoder<'_, D>,
1702            offset: usize,
1703            _depth: fidl::encoding::Depth,
1704        ) -> fidl::Result<()> {
1705            encoder.debug_check_bounds::<EnergyScanResultStreamNextResponse>(offset);
1706            // Delegate to tuple encoding.
1707            fidl::encoding::Encode::<EnergyScanResultStreamNextResponse, D>::encode(
1708                (
1709                    <fidl::encoding::Vector<EnergyScanResult, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.results),
1710                ),
1711                encoder, offset, _depth
1712            )
1713        }
1714    }
1715    unsafe impl<
1716            D: fidl::encoding::ResourceDialect,
1717            T0: fidl::encoding::Encode<fidl::encoding::Vector<EnergyScanResult, 32>, D>,
1718        > fidl::encoding::Encode<EnergyScanResultStreamNextResponse, D> for (T0,)
1719    {
1720        #[inline]
1721        unsafe fn encode(
1722            self,
1723            encoder: &mut fidl::encoding::Encoder<'_, D>,
1724            offset: usize,
1725            depth: fidl::encoding::Depth,
1726        ) -> fidl::Result<()> {
1727            encoder.debug_check_bounds::<EnergyScanResultStreamNextResponse>(offset);
1728            // Zero out padding regions. There's no need to apply masks
1729            // because the unmasked parts will be overwritten by fields.
1730            // Write the fields.
1731            self.0.encode(encoder, offset + 0, depth)?;
1732            Ok(())
1733        }
1734    }
1735
1736    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1737        for EnergyScanResultStreamNextResponse
1738    {
1739        #[inline(always)]
1740        fn new_empty() -> Self {
1741            Self { results: fidl::new_empty!(fidl::encoding::Vector<EnergyScanResult, 32>, D) }
1742        }
1743
1744        #[inline]
1745        unsafe fn decode(
1746            &mut self,
1747            decoder: &mut fidl::encoding::Decoder<'_, D>,
1748            offset: usize,
1749            _depth: fidl::encoding::Depth,
1750        ) -> fidl::Result<()> {
1751            decoder.debug_check_bounds::<Self>(offset);
1752            // Verify that padding bytes are zero.
1753            fidl::decode!(fidl::encoding::Vector<EnergyScanResult, 32>, D, &mut self.results, decoder, offset + 0, _depth)?;
1754            Ok(())
1755        }
1756    }
1757
1758    impl fidl::encoding::ValueTypeMarker for ProvisioningParams {
1759        type Borrowed<'a> = &'a Self;
1760        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1761            value
1762        }
1763    }
1764
1765    unsafe impl fidl::encoding::TypeMarker for ProvisioningParams {
1766        type Owned = Self;
1767
1768        #[inline(always)]
1769        fn inline_align(_context: fidl::encoding::Context) -> usize {
1770            8
1771        }
1772
1773        #[inline(always)]
1774        fn inline_size(_context: fidl::encoding::Context) -> usize {
1775            32
1776        }
1777    }
1778
1779    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProvisioningParams, D>
1780        for &ProvisioningParams
1781    {
1782        #[inline]
1783        unsafe fn encode(
1784            self,
1785            encoder: &mut fidl::encoding::Encoder<'_, D>,
1786            offset: usize,
1787            _depth: fidl::encoding::Depth,
1788        ) -> fidl::Result<()> {
1789            encoder.debug_check_bounds::<ProvisioningParams>(offset);
1790            // Delegate to tuple encoding.
1791            fidl::encoding::Encode::<ProvisioningParams, D>::encode(
1792                (
1793                    <Identity as fidl::encoding::ValueTypeMarker>::borrow(&self.identity),
1794                    <fidl::encoding::OptionalUnion<Credential> as fidl::encoding::ValueTypeMarker>::borrow(&self.credential),
1795                ),
1796                encoder, offset, _depth
1797            )
1798        }
1799    }
1800    unsafe impl<
1801            D: fidl::encoding::ResourceDialect,
1802            T0: fidl::encoding::Encode<Identity, D>,
1803            T1: fidl::encoding::Encode<fidl::encoding::OptionalUnion<Credential>, D>,
1804        > fidl::encoding::Encode<ProvisioningParams, D> for (T0, T1)
1805    {
1806        #[inline]
1807        unsafe fn encode(
1808            self,
1809            encoder: &mut fidl::encoding::Encoder<'_, D>,
1810            offset: usize,
1811            depth: fidl::encoding::Depth,
1812        ) -> fidl::Result<()> {
1813            encoder.debug_check_bounds::<ProvisioningParams>(offset);
1814            // Zero out padding regions. There's no need to apply masks
1815            // because the unmasked parts will be overwritten by fields.
1816            // Write the fields.
1817            self.0.encode(encoder, offset + 0, depth)?;
1818            self.1.encode(encoder, offset + 16, depth)?;
1819            Ok(())
1820        }
1821    }
1822
1823    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProvisioningParams {
1824        #[inline(always)]
1825        fn new_empty() -> Self {
1826            Self {
1827                identity: fidl::new_empty!(Identity, D),
1828                credential: fidl::new_empty!(fidl::encoding::OptionalUnion<Credential>, D),
1829            }
1830        }
1831
1832        #[inline]
1833        unsafe fn decode(
1834            &mut self,
1835            decoder: &mut fidl::encoding::Decoder<'_, D>,
1836            offset: usize,
1837            _depth: fidl::encoding::Depth,
1838        ) -> fidl::Result<()> {
1839            decoder.debug_check_bounds::<Self>(offset);
1840            // Verify that padding bytes are zero.
1841            fidl::decode!(Identity, D, &mut self.identity, decoder, offset + 0, _depth)?;
1842            fidl::decode!(
1843                fidl::encoding::OptionalUnion<Credential>,
1844                D,
1845                &mut self.credential,
1846                decoder,
1847                offset + 16,
1848                _depth
1849            )?;
1850            Ok(())
1851        }
1852    }
1853
1854    impl AllCounters {
1855        #[inline(always)]
1856        fn max_ordinal_present(&self) -> u64 {
1857            if let Some(_) = self.ip_rx {
1858                return 7;
1859            }
1860            if let Some(_) = self.ip_tx {
1861                return 6;
1862            }
1863            if let Some(_) = self.coex_saturated {
1864                return 5;
1865            }
1866            if let Some(_) = self.coex_rx {
1867                return 4;
1868            }
1869            if let Some(_) = self.coex_tx {
1870                return 3;
1871            }
1872            if let Some(_) = self.mac_rx {
1873                return 2;
1874            }
1875            if let Some(_) = self.mac_tx {
1876                return 1;
1877            }
1878            0
1879        }
1880    }
1881
1882    impl fidl::encoding::ValueTypeMarker for AllCounters {
1883        type Borrowed<'a> = &'a Self;
1884        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1885            value
1886        }
1887    }
1888
1889    unsafe impl fidl::encoding::TypeMarker for AllCounters {
1890        type Owned = Self;
1891
1892        #[inline(always)]
1893        fn inline_align(_context: fidl::encoding::Context) -> usize {
1894            8
1895        }
1896
1897        #[inline(always)]
1898        fn inline_size(_context: fidl::encoding::Context) -> usize {
1899            16
1900        }
1901    }
1902
1903    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AllCounters, D>
1904        for &AllCounters
1905    {
1906        unsafe fn encode(
1907            self,
1908            encoder: &mut fidl::encoding::Encoder<'_, D>,
1909            offset: usize,
1910            mut depth: fidl::encoding::Depth,
1911        ) -> fidl::Result<()> {
1912            encoder.debug_check_bounds::<AllCounters>(offset);
1913            // Vector header
1914            let max_ordinal: u64 = self.max_ordinal_present();
1915            encoder.write_num(max_ordinal, offset);
1916            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
1917            // Calling encoder.out_of_line_offset(0) is not allowed.
1918            if max_ordinal == 0 {
1919                return Ok(());
1920            }
1921            depth.increment()?;
1922            let envelope_size = 8;
1923            let bytes_len = max_ordinal as usize * envelope_size;
1924            #[allow(unused_variables)]
1925            let offset = encoder.out_of_line_offset(bytes_len);
1926            let mut _prev_end_offset: usize = 0;
1927            if 1 > max_ordinal {
1928                return Ok(());
1929            }
1930
1931            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1932            // are envelope_size bytes.
1933            let cur_offset: usize = (1 - 1) * envelope_size;
1934
1935            // Zero reserved fields.
1936            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1937
1938            // Safety:
1939            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1940            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1941            //   envelope_size bytes, there is always sufficient room.
1942            fidl::encoding::encode_in_envelope_optional::<MacCounters, D>(
1943                self.mac_tx.as_ref().map(<MacCounters as fidl::encoding::ValueTypeMarker>::borrow),
1944                encoder,
1945                offset + cur_offset,
1946                depth,
1947            )?;
1948
1949            _prev_end_offset = cur_offset + envelope_size;
1950            if 2 > max_ordinal {
1951                return Ok(());
1952            }
1953
1954            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1955            // are envelope_size bytes.
1956            let cur_offset: usize = (2 - 1) * envelope_size;
1957
1958            // Zero reserved fields.
1959            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1960
1961            // Safety:
1962            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1963            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1964            //   envelope_size bytes, there is always sufficient room.
1965            fidl::encoding::encode_in_envelope_optional::<MacCounters, D>(
1966                self.mac_rx.as_ref().map(<MacCounters as fidl::encoding::ValueTypeMarker>::borrow),
1967                encoder,
1968                offset + cur_offset,
1969                depth,
1970            )?;
1971
1972            _prev_end_offset = cur_offset + envelope_size;
1973            if 3 > max_ordinal {
1974                return Ok(());
1975            }
1976
1977            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
1978            // are envelope_size bytes.
1979            let cur_offset: usize = (3 - 1) * envelope_size;
1980
1981            // Zero reserved fields.
1982            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
1983
1984            // Safety:
1985            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
1986            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
1987            //   envelope_size bytes, there is always sufficient room.
1988            fidl::encoding::encode_in_envelope_optional::<CoexCounters, D>(
1989                self.coex_tx
1990                    .as_ref()
1991                    .map(<CoexCounters as fidl::encoding::ValueTypeMarker>::borrow),
1992                encoder,
1993                offset + cur_offset,
1994                depth,
1995            )?;
1996
1997            _prev_end_offset = cur_offset + envelope_size;
1998            if 4 > max_ordinal {
1999                return Ok(());
2000            }
2001
2002            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2003            // are envelope_size bytes.
2004            let cur_offset: usize = (4 - 1) * envelope_size;
2005
2006            // Zero reserved fields.
2007            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2008
2009            // Safety:
2010            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2011            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2012            //   envelope_size bytes, there is always sufficient room.
2013            fidl::encoding::encode_in_envelope_optional::<CoexCounters, D>(
2014                self.coex_rx
2015                    .as_ref()
2016                    .map(<CoexCounters as fidl::encoding::ValueTypeMarker>::borrow),
2017                encoder,
2018                offset + cur_offset,
2019                depth,
2020            )?;
2021
2022            _prev_end_offset = cur_offset + envelope_size;
2023            if 5 > max_ordinal {
2024                return Ok(());
2025            }
2026
2027            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2028            // are envelope_size bytes.
2029            let cur_offset: usize = (5 - 1) * envelope_size;
2030
2031            // Zero reserved fields.
2032            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2033
2034            // Safety:
2035            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2036            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2037            //   envelope_size bytes, there is always sufficient room.
2038            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2039                self.coex_saturated.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2040                encoder,
2041                offset + cur_offset,
2042                depth,
2043            )?;
2044
2045            _prev_end_offset = cur_offset + envelope_size;
2046            if 6 > max_ordinal {
2047                return Ok(());
2048            }
2049
2050            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2051            // are envelope_size bytes.
2052            let cur_offset: usize = (6 - 1) * envelope_size;
2053
2054            // Zero reserved fields.
2055            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2056
2057            // Safety:
2058            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2059            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2060            //   envelope_size bytes, there is always sufficient room.
2061            fidl::encoding::encode_in_envelope_optional::<IpCounters, D>(
2062                self.ip_tx.as_ref().map(<IpCounters as fidl::encoding::ValueTypeMarker>::borrow),
2063                encoder,
2064                offset + cur_offset,
2065                depth,
2066            )?;
2067
2068            _prev_end_offset = cur_offset + envelope_size;
2069            if 7 > max_ordinal {
2070                return Ok(());
2071            }
2072
2073            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2074            // are envelope_size bytes.
2075            let cur_offset: usize = (7 - 1) * envelope_size;
2076
2077            // Zero reserved fields.
2078            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2079
2080            // Safety:
2081            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2082            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2083            //   envelope_size bytes, there is always sufficient room.
2084            fidl::encoding::encode_in_envelope_optional::<IpCounters, D>(
2085                self.ip_rx.as_ref().map(<IpCounters as fidl::encoding::ValueTypeMarker>::borrow),
2086                encoder,
2087                offset + cur_offset,
2088                depth,
2089            )?;
2090
2091            _prev_end_offset = cur_offset + envelope_size;
2092
2093            Ok(())
2094        }
2095    }
2096
2097    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllCounters {
2098        #[inline(always)]
2099        fn new_empty() -> Self {
2100            Self::default()
2101        }
2102
2103        unsafe fn decode(
2104            &mut self,
2105            decoder: &mut fidl::encoding::Decoder<'_, D>,
2106            offset: usize,
2107            mut depth: fidl::encoding::Depth,
2108        ) -> fidl::Result<()> {
2109            decoder.debug_check_bounds::<Self>(offset);
2110            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2111                None => return Err(fidl::Error::NotNullable),
2112                Some(len) => len,
2113            };
2114            // Calling decoder.out_of_line_offset(0) is not allowed.
2115            if len == 0 {
2116                return Ok(());
2117            };
2118            depth.increment()?;
2119            let envelope_size = 8;
2120            let bytes_len = len * envelope_size;
2121            let offset = decoder.out_of_line_offset(bytes_len)?;
2122            // Decode the envelope for each type.
2123            let mut _next_ordinal_to_read = 0;
2124            let mut next_offset = offset;
2125            let end_offset = offset + bytes_len;
2126            _next_ordinal_to_read += 1;
2127            if next_offset >= end_offset {
2128                return Ok(());
2129            }
2130
2131            // Decode unknown envelopes for gaps in ordinals.
2132            while _next_ordinal_to_read < 1 {
2133                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2134                _next_ordinal_to_read += 1;
2135                next_offset += envelope_size;
2136            }
2137
2138            let next_out_of_line = decoder.next_out_of_line();
2139            let handles_before = decoder.remaining_handles();
2140            if let Some((inlined, num_bytes, num_handles)) =
2141                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2142            {
2143                let member_inline_size =
2144                    <MacCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2145                if inlined != (member_inline_size <= 4) {
2146                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2147                }
2148                let inner_offset;
2149                let mut inner_depth = depth.clone();
2150                if inlined {
2151                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2152                    inner_offset = next_offset;
2153                } else {
2154                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2155                    inner_depth.increment()?;
2156                }
2157                let val_ref = self.mac_tx.get_or_insert_with(|| fidl::new_empty!(MacCounters, D));
2158                fidl::decode!(MacCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
2159                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2160                {
2161                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2162                }
2163                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2164                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2165                }
2166            }
2167
2168            next_offset += envelope_size;
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 < 2 {
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_rx.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 < 3 {
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                    <CoexCounters 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.coex_tx.get_or_insert_with(|| fidl::new_empty!(CoexCounters, D));
2244                fidl::decode!(CoexCounters, 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 < 4 {
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_rx.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 < 5 {
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                    <bool 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_saturated.get_or_insert_with(|| fidl::new_empty!(bool, D));
2330                fidl::decode!(bool, 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 < 6 {
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                    <IpCounters 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.ip_tx.get_or_insert_with(|| fidl::new_empty!(IpCounters, D));
2373                fidl::decode!(IpCounters, 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 < 7 {
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_rx.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
2428            // Decode the remaining unknown envelopes.
2429            while next_offset < end_offset {
2430                _next_ordinal_to_read += 1;
2431                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2432                next_offset += envelope_size;
2433            }
2434
2435            Ok(())
2436        }
2437    }
2438
2439    impl CoexCounters {
2440        #[inline(always)]
2441        fn max_ordinal_present(&self) -> u64 {
2442            if let Some(_) = self.grant_none {
2443                return 9;
2444            }
2445            if let Some(_) = self.avg_delay_request_to_grant_usec {
2446                return 8;
2447            }
2448            if let Some(_) = self.delayed_grant {
2449                return 7;
2450            }
2451            if let Some(_) = self.grant_deactivated_during_request {
2452                return 6;
2453            }
2454            if let Some(_) = self.grant_wait_timeout {
2455                return 5;
2456            }
2457            if let Some(_) = self.grant_wait_activated {
2458                return 4;
2459            }
2460            if let Some(_) = self.grant_wait {
2461                return 3;
2462            }
2463            if let Some(_) = self.grant_immediate {
2464                return 2;
2465            }
2466            if let Some(_) = self.requests {
2467                return 1;
2468            }
2469            0
2470        }
2471    }
2472
2473    impl fidl::encoding::ValueTypeMarker for CoexCounters {
2474        type Borrowed<'a> = &'a Self;
2475        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2476            value
2477        }
2478    }
2479
2480    unsafe impl fidl::encoding::TypeMarker for CoexCounters {
2481        type Owned = Self;
2482
2483        #[inline(always)]
2484        fn inline_align(_context: fidl::encoding::Context) -> usize {
2485            8
2486        }
2487
2488        #[inline(always)]
2489        fn inline_size(_context: fidl::encoding::Context) -> usize {
2490            16
2491        }
2492    }
2493
2494    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CoexCounters, D>
2495        for &CoexCounters
2496    {
2497        unsafe fn encode(
2498            self,
2499            encoder: &mut fidl::encoding::Encoder<'_, D>,
2500            offset: usize,
2501            mut depth: fidl::encoding::Depth,
2502        ) -> fidl::Result<()> {
2503            encoder.debug_check_bounds::<CoexCounters>(offset);
2504            // Vector header
2505            let max_ordinal: u64 = self.max_ordinal_present();
2506            encoder.write_num(max_ordinal, offset);
2507            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2508            // Calling encoder.out_of_line_offset(0) is not allowed.
2509            if max_ordinal == 0 {
2510                return Ok(());
2511            }
2512            depth.increment()?;
2513            let envelope_size = 8;
2514            let bytes_len = max_ordinal as usize * envelope_size;
2515            #[allow(unused_variables)]
2516            let offset = encoder.out_of_line_offset(bytes_len);
2517            let mut _prev_end_offset: usize = 0;
2518            if 1 > max_ordinal {
2519                return Ok(());
2520            }
2521
2522            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2523            // are envelope_size bytes.
2524            let cur_offset: usize = (1 - 1) * envelope_size;
2525
2526            // Zero reserved fields.
2527            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2528
2529            // Safety:
2530            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2531            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2532            //   envelope_size bytes, there is always sufficient room.
2533            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2534                self.requests.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2535                encoder,
2536                offset + cur_offset,
2537                depth,
2538            )?;
2539
2540            _prev_end_offset = cur_offset + envelope_size;
2541            if 2 > max_ordinal {
2542                return Ok(());
2543            }
2544
2545            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2546            // are envelope_size bytes.
2547            let cur_offset: usize = (2 - 1) * envelope_size;
2548
2549            // Zero reserved fields.
2550            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2551
2552            // Safety:
2553            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2554            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2555            //   envelope_size bytes, there is always sufficient room.
2556            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2557                self.grant_immediate.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2558                encoder,
2559                offset + cur_offset,
2560                depth,
2561            )?;
2562
2563            _prev_end_offset = cur_offset + envelope_size;
2564            if 3 > max_ordinal {
2565                return Ok(());
2566            }
2567
2568            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2569            // are envelope_size bytes.
2570            let cur_offset: usize = (3 - 1) * envelope_size;
2571
2572            // Zero reserved fields.
2573            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2574
2575            // Safety:
2576            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2577            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2578            //   envelope_size bytes, there is always sufficient room.
2579            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2580                self.grant_wait.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2581                encoder,
2582                offset + cur_offset,
2583                depth,
2584            )?;
2585
2586            _prev_end_offset = cur_offset + envelope_size;
2587            if 4 > max_ordinal {
2588                return Ok(());
2589            }
2590
2591            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2592            // are envelope_size bytes.
2593            let cur_offset: usize = (4 - 1) * envelope_size;
2594
2595            // Zero reserved fields.
2596            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2597
2598            // Safety:
2599            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2600            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2601            //   envelope_size bytes, there is always sufficient room.
2602            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2603                self.grant_wait_activated
2604                    .as_ref()
2605                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2606                encoder,
2607                offset + cur_offset,
2608                depth,
2609            )?;
2610
2611            _prev_end_offset = cur_offset + envelope_size;
2612            if 5 > max_ordinal {
2613                return Ok(());
2614            }
2615
2616            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2617            // are envelope_size bytes.
2618            let cur_offset: usize = (5 - 1) * envelope_size;
2619
2620            // Zero reserved fields.
2621            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2622
2623            // Safety:
2624            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2625            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2626            //   envelope_size bytes, there is always sufficient room.
2627            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2628                self.grant_wait_timeout
2629                    .as_ref()
2630                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2631                encoder,
2632                offset + cur_offset,
2633                depth,
2634            )?;
2635
2636            _prev_end_offset = cur_offset + envelope_size;
2637            if 6 > max_ordinal {
2638                return Ok(());
2639            }
2640
2641            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2642            // are envelope_size bytes.
2643            let cur_offset: usize = (6 - 1) * envelope_size;
2644
2645            // Zero reserved fields.
2646            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2647
2648            // Safety:
2649            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2650            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2651            //   envelope_size bytes, there is always sufficient room.
2652            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2653                self.grant_deactivated_during_request
2654                    .as_ref()
2655                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2656                encoder,
2657                offset + cur_offset,
2658                depth,
2659            )?;
2660
2661            _prev_end_offset = cur_offset + envelope_size;
2662            if 7 > max_ordinal {
2663                return Ok(());
2664            }
2665
2666            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2667            // are envelope_size bytes.
2668            let cur_offset: usize = (7 - 1) * envelope_size;
2669
2670            // Zero reserved fields.
2671            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2672
2673            // Safety:
2674            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2675            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2676            //   envelope_size bytes, there is always sufficient room.
2677            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2678                self.delayed_grant.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2679                encoder,
2680                offset + cur_offset,
2681                depth,
2682            )?;
2683
2684            _prev_end_offset = cur_offset + envelope_size;
2685            if 8 > max_ordinal {
2686                return Ok(());
2687            }
2688
2689            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2690            // are envelope_size bytes.
2691            let cur_offset: usize = (8 - 1) * envelope_size;
2692
2693            // Zero reserved fields.
2694            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2695
2696            // Safety:
2697            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2698            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2699            //   envelope_size bytes, there is always sufficient room.
2700            fidl::encoding::encode_in_envelope_optional::<u32, D>(
2701                self.avg_delay_request_to_grant_usec
2702                    .as_ref()
2703                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2704                encoder,
2705                offset + cur_offset,
2706                depth,
2707            )?;
2708
2709            _prev_end_offset = cur_offset + envelope_size;
2710            if 9 > max_ordinal {
2711                return Ok(());
2712            }
2713
2714            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2715            // are envelope_size bytes.
2716            let cur_offset: usize = (9 - 1) * envelope_size;
2717
2718            // Zero reserved fields.
2719            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2720
2721            // Safety:
2722            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2723            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2724            //   envelope_size bytes, there is always sufficient room.
2725            fidl::encoding::encode_in_envelope_optional::<u64, D>(
2726                self.grant_none.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
2727                encoder,
2728                offset + cur_offset,
2729                depth,
2730            )?;
2731
2732            _prev_end_offset = cur_offset + envelope_size;
2733
2734            Ok(())
2735        }
2736    }
2737
2738    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CoexCounters {
2739        #[inline(always)]
2740        fn new_empty() -> Self {
2741            Self::default()
2742        }
2743
2744        unsafe fn decode(
2745            &mut self,
2746            decoder: &mut fidl::encoding::Decoder<'_, D>,
2747            offset: usize,
2748            mut depth: fidl::encoding::Depth,
2749        ) -> fidl::Result<()> {
2750            decoder.debug_check_bounds::<Self>(offset);
2751            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2752                None => return Err(fidl::Error::NotNullable),
2753                Some(len) => len,
2754            };
2755            // Calling decoder.out_of_line_offset(0) is not allowed.
2756            if len == 0 {
2757                return Ok(());
2758            };
2759            depth.increment()?;
2760            let envelope_size = 8;
2761            let bytes_len = len * envelope_size;
2762            let offset = decoder.out_of_line_offset(bytes_len)?;
2763            // Decode the envelope for each type.
2764            let mut _next_ordinal_to_read = 0;
2765            let mut next_offset = offset;
2766            let end_offset = offset + bytes_len;
2767            _next_ordinal_to_read += 1;
2768            if next_offset >= end_offset {
2769                return Ok(());
2770            }
2771
2772            // Decode unknown envelopes for gaps in ordinals.
2773            while _next_ordinal_to_read < 1 {
2774                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2775                _next_ordinal_to_read += 1;
2776                next_offset += envelope_size;
2777            }
2778
2779            let next_out_of_line = decoder.next_out_of_line();
2780            let handles_before = decoder.remaining_handles();
2781            if let Some((inlined, num_bytes, num_handles)) =
2782                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2783            {
2784                let member_inline_size =
2785                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2786                if inlined != (member_inline_size <= 4) {
2787                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2788                }
2789                let inner_offset;
2790                let mut inner_depth = depth.clone();
2791                if inlined {
2792                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2793                    inner_offset = next_offset;
2794                } else {
2795                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2796                    inner_depth.increment()?;
2797                }
2798                let val_ref = self.requests.get_or_insert_with(|| fidl::new_empty!(u64, D));
2799                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2800                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2801                {
2802                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2803                }
2804                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2805                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2806                }
2807            }
2808
2809            next_offset += envelope_size;
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 < 2 {
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.grant_immediate.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 < 3 {
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_wait.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 < 4 {
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 =
2928                    self.grant_wait_activated.get_or_insert_with(|| fidl::new_empty!(u64, D));
2929                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2930                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2931                {
2932                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2933                }
2934                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2935                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2936                }
2937            }
2938
2939            next_offset += envelope_size;
2940            _next_ordinal_to_read += 1;
2941            if next_offset >= end_offset {
2942                return Ok(());
2943            }
2944
2945            // Decode unknown envelopes for gaps in ordinals.
2946            while _next_ordinal_to_read < 5 {
2947                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2948                _next_ordinal_to_read += 1;
2949                next_offset += envelope_size;
2950            }
2951
2952            let next_out_of_line = decoder.next_out_of_line();
2953            let handles_before = decoder.remaining_handles();
2954            if let Some((inlined, num_bytes, num_handles)) =
2955                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2956            {
2957                let member_inline_size =
2958                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2959                if inlined != (member_inline_size <= 4) {
2960                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2961                }
2962                let inner_offset;
2963                let mut inner_depth = depth.clone();
2964                if inlined {
2965                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2966                    inner_offset = next_offset;
2967                } else {
2968                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2969                    inner_depth.increment()?;
2970                }
2971                let val_ref =
2972                    self.grant_wait_timeout.get_or_insert_with(|| fidl::new_empty!(u64, D));
2973                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
2974                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2975                {
2976                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2977                }
2978                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2979                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2980                }
2981            }
2982
2983            next_offset += envelope_size;
2984            _next_ordinal_to_read += 1;
2985            if next_offset >= end_offset {
2986                return Ok(());
2987            }
2988
2989            // Decode unknown envelopes for gaps in ordinals.
2990            while _next_ordinal_to_read < 6 {
2991                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2992                _next_ordinal_to_read += 1;
2993                next_offset += envelope_size;
2994            }
2995
2996            let next_out_of_line = decoder.next_out_of_line();
2997            let handles_before = decoder.remaining_handles();
2998            if let Some((inlined, num_bytes, num_handles)) =
2999                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3000            {
3001                let member_inline_size =
3002                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3003                if inlined != (member_inline_size <= 4) {
3004                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3005                }
3006                let inner_offset;
3007                let mut inner_depth = depth.clone();
3008                if inlined {
3009                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3010                    inner_offset = next_offset;
3011                } else {
3012                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3013                    inner_depth.increment()?;
3014                }
3015                let val_ref = self
3016                    .grant_deactivated_during_request
3017                    .get_or_insert_with(|| fidl::new_empty!(u64, D));
3018                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3019                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3020                {
3021                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3022                }
3023                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3024                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3025                }
3026            }
3027
3028            next_offset += envelope_size;
3029            _next_ordinal_to_read += 1;
3030            if next_offset >= end_offset {
3031                return Ok(());
3032            }
3033
3034            // Decode unknown envelopes for gaps in ordinals.
3035            while _next_ordinal_to_read < 7 {
3036                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3037                _next_ordinal_to_read += 1;
3038                next_offset += envelope_size;
3039            }
3040
3041            let next_out_of_line = decoder.next_out_of_line();
3042            let handles_before = decoder.remaining_handles();
3043            if let Some((inlined, num_bytes, num_handles)) =
3044                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3045            {
3046                let member_inline_size =
3047                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3048                if inlined != (member_inline_size <= 4) {
3049                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3050                }
3051                let inner_offset;
3052                let mut inner_depth = depth.clone();
3053                if inlined {
3054                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3055                    inner_offset = next_offset;
3056                } else {
3057                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3058                    inner_depth.increment()?;
3059                }
3060                let val_ref = self.delayed_grant.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 < 8 {
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                    <u32 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
3104                    .avg_delay_request_to_grant_usec
3105                    .get_or_insert_with(|| fidl::new_empty!(u32, D));
3106                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3107                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3108                {
3109                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3110                }
3111                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3112                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3113                }
3114            }
3115
3116            next_offset += envelope_size;
3117            _next_ordinal_to_read += 1;
3118            if next_offset >= end_offset {
3119                return Ok(());
3120            }
3121
3122            // Decode unknown envelopes for gaps in ordinals.
3123            while _next_ordinal_to_read < 9 {
3124                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3125                _next_ordinal_to_read += 1;
3126                next_offset += envelope_size;
3127            }
3128
3129            let next_out_of_line = decoder.next_out_of_line();
3130            let handles_before = decoder.remaining_handles();
3131            if let Some((inlined, num_bytes, num_handles)) =
3132                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3133            {
3134                let member_inline_size =
3135                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3136                if inlined != (member_inline_size <= 4) {
3137                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3138                }
3139                let inner_offset;
3140                let mut inner_depth = depth.clone();
3141                if inlined {
3142                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3143                    inner_offset = next_offset;
3144                } else {
3145                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3146                    inner_depth.increment()?;
3147                }
3148                let val_ref = self.grant_none.get_or_insert_with(|| fidl::new_empty!(u64, D));
3149                fidl::decode!(u64, 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
3161            // Decode the remaining unknown envelopes.
3162            while next_offset < end_offset {
3163                _next_ordinal_to_read += 1;
3164                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3165                next_offset += envelope_size;
3166            }
3167
3168            Ok(())
3169        }
3170    }
3171
3172    impl DeviceState {
3173        #[inline(always)]
3174        fn max_ordinal_present(&self) -> u64 {
3175            if let Some(_) = self.role {
3176                return 2;
3177            }
3178            if let Some(_) = self.connectivity_state {
3179                return 1;
3180            }
3181            0
3182        }
3183    }
3184
3185    impl fidl::encoding::ValueTypeMarker for DeviceState {
3186        type Borrowed<'a> = &'a Self;
3187        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3188            value
3189        }
3190    }
3191
3192    unsafe impl fidl::encoding::TypeMarker for DeviceState {
3193        type Owned = Self;
3194
3195        #[inline(always)]
3196        fn inline_align(_context: fidl::encoding::Context) -> usize {
3197            8
3198        }
3199
3200        #[inline(always)]
3201        fn inline_size(_context: fidl::encoding::Context) -> usize {
3202            16
3203        }
3204    }
3205
3206    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DeviceState, D>
3207        for &DeviceState
3208    {
3209        unsafe fn encode(
3210            self,
3211            encoder: &mut fidl::encoding::Encoder<'_, D>,
3212            offset: usize,
3213            mut depth: fidl::encoding::Depth,
3214        ) -> fidl::Result<()> {
3215            encoder.debug_check_bounds::<DeviceState>(offset);
3216            // Vector header
3217            let max_ordinal: u64 = self.max_ordinal_present();
3218            encoder.write_num(max_ordinal, offset);
3219            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3220            // Calling encoder.out_of_line_offset(0) is not allowed.
3221            if max_ordinal == 0 {
3222                return Ok(());
3223            }
3224            depth.increment()?;
3225            let envelope_size = 8;
3226            let bytes_len = max_ordinal as usize * envelope_size;
3227            #[allow(unused_variables)]
3228            let offset = encoder.out_of_line_offset(bytes_len);
3229            let mut _prev_end_offset: usize = 0;
3230            if 1 > max_ordinal {
3231                return Ok(());
3232            }
3233
3234            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3235            // are envelope_size bytes.
3236            let cur_offset: usize = (1 - 1) * envelope_size;
3237
3238            // Zero reserved fields.
3239            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3240
3241            // Safety:
3242            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3243            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3244            //   envelope_size bytes, there is always sufficient room.
3245            fidl::encoding::encode_in_envelope_optional::<ConnectivityState, D>(
3246                self.connectivity_state
3247                    .as_ref()
3248                    .map(<ConnectivityState as fidl::encoding::ValueTypeMarker>::borrow),
3249                encoder,
3250                offset + cur_offset,
3251                depth,
3252            )?;
3253
3254            _prev_end_offset = cur_offset + envelope_size;
3255            if 2 > max_ordinal {
3256                return Ok(());
3257            }
3258
3259            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3260            // are envelope_size bytes.
3261            let cur_offset: usize = (2 - 1) * envelope_size;
3262
3263            // Zero reserved fields.
3264            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3265
3266            // Safety:
3267            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3268            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3269            //   envelope_size bytes, there is always sufficient room.
3270            fidl::encoding::encode_in_envelope_optional::<Role, D>(
3271                self.role.as_ref().map(<Role as fidl::encoding::ValueTypeMarker>::borrow),
3272                encoder,
3273                offset + cur_offset,
3274                depth,
3275            )?;
3276
3277            _prev_end_offset = cur_offset + envelope_size;
3278
3279            Ok(())
3280        }
3281    }
3282
3283    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DeviceState {
3284        #[inline(always)]
3285        fn new_empty() -> Self {
3286            Self::default()
3287        }
3288
3289        unsafe fn decode(
3290            &mut self,
3291            decoder: &mut fidl::encoding::Decoder<'_, D>,
3292            offset: usize,
3293            mut depth: fidl::encoding::Depth,
3294        ) -> fidl::Result<()> {
3295            decoder.debug_check_bounds::<Self>(offset);
3296            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3297                None => return Err(fidl::Error::NotNullable),
3298                Some(len) => len,
3299            };
3300            // Calling decoder.out_of_line_offset(0) is not allowed.
3301            if len == 0 {
3302                return Ok(());
3303            };
3304            depth.increment()?;
3305            let envelope_size = 8;
3306            let bytes_len = len * envelope_size;
3307            let offset = decoder.out_of_line_offset(bytes_len)?;
3308            // Decode the envelope for each type.
3309            let mut _next_ordinal_to_read = 0;
3310            let mut next_offset = offset;
3311            let end_offset = offset + bytes_len;
3312            _next_ordinal_to_read += 1;
3313            if next_offset >= end_offset {
3314                return Ok(());
3315            }
3316
3317            // Decode unknown envelopes for gaps in ordinals.
3318            while _next_ordinal_to_read < 1 {
3319                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3320                _next_ordinal_to_read += 1;
3321                next_offset += envelope_size;
3322            }
3323
3324            let next_out_of_line = decoder.next_out_of_line();
3325            let handles_before = decoder.remaining_handles();
3326            if let Some((inlined, num_bytes, num_handles)) =
3327                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3328            {
3329                let member_inline_size =
3330                    <ConnectivityState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3331                if inlined != (member_inline_size <= 4) {
3332                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3333                }
3334                let inner_offset;
3335                let mut inner_depth = depth.clone();
3336                if inlined {
3337                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3338                    inner_offset = next_offset;
3339                } else {
3340                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3341                    inner_depth.increment()?;
3342                }
3343                let val_ref = self
3344                    .connectivity_state
3345                    .get_or_insert_with(|| fidl::new_empty!(ConnectivityState, D));
3346                fidl::decode!(ConnectivityState, D, val_ref, decoder, inner_offset, inner_depth)?;
3347                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3348                {
3349                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3350                }
3351                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3352                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3353                }
3354            }
3355
3356            next_offset += envelope_size;
3357            _next_ordinal_to_read += 1;
3358            if next_offset >= end_offset {
3359                return Ok(());
3360            }
3361
3362            // Decode unknown envelopes for gaps in ordinals.
3363            while _next_ordinal_to_read < 2 {
3364                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3365                _next_ordinal_to_read += 1;
3366                next_offset += envelope_size;
3367            }
3368
3369            let next_out_of_line = decoder.next_out_of_line();
3370            let handles_before = decoder.remaining_handles();
3371            if let Some((inlined, num_bytes, num_handles)) =
3372                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3373            {
3374                let member_inline_size =
3375                    <Role as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3376                if inlined != (member_inline_size <= 4) {
3377                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3378                }
3379                let inner_offset;
3380                let mut inner_depth = depth.clone();
3381                if inlined {
3382                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3383                    inner_offset = next_offset;
3384                } else {
3385                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3386                    inner_depth.increment()?;
3387                }
3388                let val_ref = self.role.get_or_insert_with(|| fidl::new_empty!(Role, D));
3389                fidl::decode!(Role, 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
3401            // Decode the remaining unknown envelopes.
3402            while next_offset < end_offset {
3403                _next_ordinal_to_read += 1;
3404                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3405                next_offset += envelope_size;
3406            }
3407
3408            Ok(())
3409        }
3410    }
3411
3412    impl EnergyScanParameters {
3413        #[inline(always)]
3414        fn max_ordinal_present(&self) -> u64 {
3415            if let Some(_) = self.dwell_time_ms {
3416                return 2;
3417            }
3418            if let Some(_) = self.channels {
3419                return 1;
3420            }
3421            0
3422        }
3423    }
3424
3425    impl fidl::encoding::ValueTypeMarker for EnergyScanParameters {
3426        type Borrowed<'a> = &'a Self;
3427        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3428            value
3429        }
3430    }
3431
3432    unsafe impl fidl::encoding::TypeMarker for EnergyScanParameters {
3433        type Owned = Self;
3434
3435        #[inline(always)]
3436        fn inline_align(_context: fidl::encoding::Context) -> usize {
3437            8
3438        }
3439
3440        #[inline(always)]
3441        fn inline_size(_context: fidl::encoding::Context) -> usize {
3442            16
3443        }
3444    }
3445
3446    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EnergyScanParameters, D>
3447        for &EnergyScanParameters
3448    {
3449        unsafe fn encode(
3450            self,
3451            encoder: &mut fidl::encoding::Encoder<'_, D>,
3452            offset: usize,
3453            mut depth: fidl::encoding::Depth,
3454        ) -> fidl::Result<()> {
3455            encoder.debug_check_bounds::<EnergyScanParameters>(offset);
3456            // Vector header
3457            let max_ordinal: u64 = self.max_ordinal_present();
3458            encoder.write_num(max_ordinal, offset);
3459            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3460            // Calling encoder.out_of_line_offset(0) is not allowed.
3461            if max_ordinal == 0 {
3462                return Ok(());
3463            }
3464            depth.increment()?;
3465            let envelope_size = 8;
3466            let bytes_len = max_ordinal as usize * envelope_size;
3467            #[allow(unused_variables)]
3468            let offset = encoder.out_of_line_offset(bytes_len);
3469            let mut _prev_end_offset: usize = 0;
3470            if 1 > max_ordinal {
3471                return Ok(());
3472            }
3473
3474            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3475            // are envelope_size bytes.
3476            let cur_offset: usize = (1 - 1) * envelope_size;
3477
3478            // Zero reserved fields.
3479            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3480
3481            // Safety:
3482            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3483            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3484            //   envelope_size bytes, there is always sufficient room.
3485            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u16, 200>, D>(
3486                self.channels.as_ref().map(
3487                    <fidl::encoding::Vector<u16, 200> as fidl::encoding::ValueTypeMarker>::borrow,
3488                ),
3489                encoder,
3490                offset + cur_offset,
3491                depth,
3492            )?;
3493
3494            _prev_end_offset = cur_offset + envelope_size;
3495            if 2 > max_ordinal {
3496                return Ok(());
3497            }
3498
3499            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3500            // are envelope_size bytes.
3501            let cur_offset: usize = (2 - 1) * envelope_size;
3502
3503            // Zero reserved fields.
3504            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3505
3506            // Safety:
3507            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3508            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3509            //   envelope_size bytes, there is always sufficient room.
3510            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3511                self.dwell_time_ms.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3512                encoder,
3513                offset + cur_offset,
3514                depth,
3515            )?;
3516
3517            _prev_end_offset = cur_offset + envelope_size;
3518
3519            Ok(())
3520        }
3521    }
3522
3523    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnergyScanParameters {
3524        #[inline(always)]
3525        fn new_empty() -> Self {
3526            Self::default()
3527        }
3528
3529        unsafe fn decode(
3530            &mut self,
3531            decoder: &mut fidl::encoding::Decoder<'_, D>,
3532            offset: usize,
3533            mut depth: fidl::encoding::Depth,
3534        ) -> fidl::Result<()> {
3535            decoder.debug_check_bounds::<Self>(offset);
3536            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3537                None => return Err(fidl::Error::NotNullable),
3538                Some(len) => len,
3539            };
3540            // Calling decoder.out_of_line_offset(0) is not allowed.
3541            if len == 0 {
3542                return Ok(());
3543            };
3544            depth.increment()?;
3545            let envelope_size = 8;
3546            let bytes_len = len * envelope_size;
3547            let offset = decoder.out_of_line_offset(bytes_len)?;
3548            // Decode the envelope for each type.
3549            let mut _next_ordinal_to_read = 0;
3550            let mut next_offset = offset;
3551            let end_offset = offset + bytes_len;
3552            _next_ordinal_to_read += 1;
3553            if next_offset >= end_offset {
3554                return Ok(());
3555            }
3556
3557            // Decode unknown envelopes for gaps in ordinals.
3558            while _next_ordinal_to_read < 1 {
3559                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3560                _next_ordinal_to_read += 1;
3561                next_offset += envelope_size;
3562            }
3563
3564            let next_out_of_line = decoder.next_out_of_line();
3565            let handles_before = decoder.remaining_handles();
3566            if let Some((inlined, num_bytes, num_handles)) =
3567                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3568            {
3569                let member_inline_size =
3570                    <fidl::encoding::Vector<u16, 200> as fidl::encoding::TypeMarker>::inline_size(
3571                        decoder.context,
3572                    );
3573                if inlined != (member_inline_size <= 4) {
3574                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3575                }
3576                let inner_offset;
3577                let mut inner_depth = depth.clone();
3578                if inlined {
3579                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3580                    inner_offset = next_offset;
3581                } else {
3582                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3583                    inner_depth.increment()?;
3584                }
3585                let val_ref = self
3586                    .channels
3587                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u16, 200>, D));
3588                fidl::decode!(fidl::encoding::Vector<u16, 200>, D, val_ref, decoder, inner_offset, inner_depth)?;
3589                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3590                {
3591                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3592                }
3593                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3594                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3595                }
3596            }
3597
3598            next_offset += envelope_size;
3599            _next_ordinal_to_read += 1;
3600            if next_offset >= end_offset {
3601                return Ok(());
3602            }
3603
3604            // Decode unknown envelopes for gaps in ordinals.
3605            while _next_ordinal_to_read < 2 {
3606                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3607                _next_ordinal_to_read += 1;
3608                next_offset += envelope_size;
3609            }
3610
3611            let next_out_of_line = decoder.next_out_of_line();
3612            let handles_before = decoder.remaining_handles();
3613            if let Some((inlined, num_bytes, num_handles)) =
3614                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3615            {
3616                let member_inline_size =
3617                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3618                if inlined != (member_inline_size <= 4) {
3619                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3620                }
3621                let inner_offset;
3622                let mut inner_depth = depth.clone();
3623                if inlined {
3624                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3625                    inner_offset = next_offset;
3626                } else {
3627                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3628                    inner_depth.increment()?;
3629                }
3630                let val_ref = self.dwell_time_ms.get_or_insert_with(|| fidl::new_empty!(u32, D));
3631                fidl::decode!(u32, 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
3643            // Decode the remaining unknown envelopes.
3644            while next_offset < end_offset {
3645                _next_ordinal_to_read += 1;
3646                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3647                next_offset += envelope_size;
3648            }
3649
3650            Ok(())
3651        }
3652    }
3653
3654    impl EnergyScanResult {
3655        #[inline(always)]
3656        fn max_ordinal_present(&self) -> u64 {
3657            if let Some(_) = self.min_rssi {
3658                return 3;
3659            }
3660            if let Some(_) = self.max_rssi {
3661                return 2;
3662            }
3663            if let Some(_) = self.channel_index {
3664                return 1;
3665            }
3666            0
3667        }
3668    }
3669
3670    impl fidl::encoding::ValueTypeMarker for EnergyScanResult {
3671        type Borrowed<'a> = &'a Self;
3672        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3673            value
3674        }
3675    }
3676
3677    unsafe impl fidl::encoding::TypeMarker for EnergyScanResult {
3678        type Owned = Self;
3679
3680        #[inline(always)]
3681        fn inline_align(_context: fidl::encoding::Context) -> usize {
3682            8
3683        }
3684
3685        #[inline(always)]
3686        fn inline_size(_context: fidl::encoding::Context) -> usize {
3687            16
3688        }
3689    }
3690
3691    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<EnergyScanResult, D>
3692        for &EnergyScanResult
3693    {
3694        unsafe fn encode(
3695            self,
3696            encoder: &mut fidl::encoding::Encoder<'_, D>,
3697            offset: usize,
3698            mut depth: fidl::encoding::Depth,
3699        ) -> fidl::Result<()> {
3700            encoder.debug_check_bounds::<EnergyScanResult>(offset);
3701            // Vector header
3702            let max_ordinal: u64 = self.max_ordinal_present();
3703            encoder.write_num(max_ordinal, offset);
3704            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3705            // Calling encoder.out_of_line_offset(0) is not allowed.
3706            if max_ordinal == 0 {
3707                return Ok(());
3708            }
3709            depth.increment()?;
3710            let envelope_size = 8;
3711            let bytes_len = max_ordinal as usize * envelope_size;
3712            #[allow(unused_variables)]
3713            let offset = encoder.out_of_line_offset(bytes_len);
3714            let mut _prev_end_offset: usize = 0;
3715            if 1 > max_ordinal {
3716                return Ok(());
3717            }
3718
3719            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3720            // are envelope_size bytes.
3721            let cur_offset: usize = (1 - 1) * envelope_size;
3722
3723            // Zero reserved fields.
3724            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3725
3726            // Safety:
3727            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3728            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3729            //   envelope_size bytes, there is always sufficient room.
3730            fidl::encoding::encode_in_envelope_optional::<u16, D>(
3731                self.channel_index.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3732                encoder,
3733                offset + cur_offset,
3734                depth,
3735            )?;
3736
3737            _prev_end_offset = cur_offset + envelope_size;
3738            if 2 > max_ordinal {
3739                return Ok(());
3740            }
3741
3742            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3743            // are envelope_size bytes.
3744            let cur_offset: usize = (2 - 1) * envelope_size;
3745
3746            // Zero reserved fields.
3747            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3748
3749            // Safety:
3750            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3751            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3752            //   envelope_size bytes, there is always sufficient room.
3753            fidl::encoding::encode_in_envelope_optional::<i32, D>(
3754                self.max_rssi.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
3755                encoder,
3756                offset + cur_offset,
3757                depth,
3758            )?;
3759
3760            _prev_end_offset = cur_offset + envelope_size;
3761            if 3 > max_ordinal {
3762                return Ok(());
3763            }
3764
3765            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3766            // are envelope_size bytes.
3767            let cur_offset: usize = (3 - 1) * envelope_size;
3768
3769            // Zero reserved fields.
3770            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3771
3772            // Safety:
3773            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3774            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3775            //   envelope_size bytes, there is always sufficient room.
3776            fidl::encoding::encode_in_envelope_optional::<i32, D>(
3777                self.min_rssi.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
3778                encoder,
3779                offset + cur_offset,
3780                depth,
3781            )?;
3782
3783            _prev_end_offset = cur_offset + envelope_size;
3784
3785            Ok(())
3786        }
3787    }
3788
3789    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EnergyScanResult {
3790        #[inline(always)]
3791        fn new_empty() -> Self {
3792            Self::default()
3793        }
3794
3795        unsafe fn decode(
3796            &mut self,
3797            decoder: &mut fidl::encoding::Decoder<'_, D>,
3798            offset: usize,
3799            mut depth: fidl::encoding::Depth,
3800        ) -> fidl::Result<()> {
3801            decoder.debug_check_bounds::<Self>(offset);
3802            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3803                None => return Err(fidl::Error::NotNullable),
3804                Some(len) => len,
3805            };
3806            // Calling decoder.out_of_line_offset(0) is not allowed.
3807            if len == 0 {
3808                return Ok(());
3809            };
3810            depth.increment()?;
3811            let envelope_size = 8;
3812            let bytes_len = len * envelope_size;
3813            let offset = decoder.out_of_line_offset(bytes_len)?;
3814            // Decode the envelope for each type.
3815            let mut _next_ordinal_to_read = 0;
3816            let mut next_offset = offset;
3817            let end_offset = offset + bytes_len;
3818            _next_ordinal_to_read += 1;
3819            if next_offset >= end_offset {
3820                return Ok(());
3821            }
3822
3823            // Decode unknown envelopes for gaps in ordinals.
3824            while _next_ordinal_to_read < 1 {
3825                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3826                _next_ordinal_to_read += 1;
3827                next_offset += envelope_size;
3828            }
3829
3830            let next_out_of_line = decoder.next_out_of_line();
3831            let handles_before = decoder.remaining_handles();
3832            if let Some((inlined, num_bytes, num_handles)) =
3833                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3834            {
3835                let member_inline_size =
3836                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3837                if inlined != (member_inline_size <= 4) {
3838                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3839                }
3840                let inner_offset;
3841                let mut inner_depth = depth.clone();
3842                if inlined {
3843                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3844                    inner_offset = next_offset;
3845                } else {
3846                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3847                    inner_depth.increment()?;
3848                }
3849                let val_ref = self.channel_index.get_or_insert_with(|| fidl::new_empty!(u16, D));
3850                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
3851                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3852                {
3853                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3854                }
3855                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3856                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3857                }
3858            }
3859
3860            next_offset += envelope_size;
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 < 2 {
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                    <i32 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.max_rssi.get_or_insert_with(|| fidl::new_empty!(i32, D));
3893                fidl::decode!(i32, 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 < 3 {
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.min_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
3948            // Decode the remaining unknown envelopes.
3949            while next_offset < end_offset {
3950                _next_ordinal_to_read += 1;
3951                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3952                next_offset += envelope_size;
3953            }
3954
3955            Ok(())
3956        }
3957    }
3958
3959    impl Identity {
3960        #[inline(always)]
3961        fn max_ordinal_present(&self) -> u64 {
3962            if let Some(_) = self.xpanid {
3963                return 7;
3964            }
3965            if let Some(_) = self.mesh_local_prefix {
3966                return 6;
3967            }
3968            if let Some(_) = self.panid {
3969                return 5;
3970            }
3971            if let Some(_) = self.channel {
3972                return 4;
3973            }
3974            if let Some(_) = self.net_type {
3975                return 3;
3976            }
3977            if let Some(_) = self.raw_name {
3978                return 1;
3979            }
3980            0
3981        }
3982    }
3983
3984    impl fidl::encoding::ValueTypeMarker for Identity {
3985        type Borrowed<'a> = &'a Self;
3986        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3987            value
3988        }
3989    }
3990
3991    unsafe impl fidl::encoding::TypeMarker for Identity {
3992        type Owned = Self;
3993
3994        #[inline(always)]
3995        fn inline_align(_context: fidl::encoding::Context) -> usize {
3996            8
3997        }
3998
3999        #[inline(always)]
4000        fn inline_size(_context: fidl::encoding::Context) -> usize {
4001            16
4002        }
4003    }
4004
4005    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Identity, D> for &Identity {
4006        unsafe fn encode(
4007            self,
4008            encoder: &mut fidl::encoding::Encoder<'_, D>,
4009            offset: usize,
4010            mut depth: fidl::encoding::Depth,
4011        ) -> fidl::Result<()> {
4012            encoder.debug_check_bounds::<Identity>(offset);
4013            // Vector header
4014            let max_ordinal: u64 = self.max_ordinal_present();
4015            encoder.write_num(max_ordinal, offset);
4016            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4017            // Calling encoder.out_of_line_offset(0) is not allowed.
4018            if max_ordinal == 0 {
4019                return Ok(());
4020            }
4021            depth.increment()?;
4022            let envelope_size = 8;
4023            let bytes_len = max_ordinal as usize * envelope_size;
4024            #[allow(unused_variables)]
4025            let offset = encoder.out_of_line_offset(bytes_len);
4026            let mut _prev_end_offset: usize = 0;
4027            if 1 > max_ordinal {
4028                return Ok(());
4029            }
4030
4031            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4032            // are envelope_size bytes.
4033            let cur_offset: usize = (1 - 1) * envelope_size;
4034
4035            // Zero reserved fields.
4036            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4037
4038            // Safety:
4039            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4040            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4041            //   envelope_size bytes, there is always sufficient room.
4042            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 63>, D>(
4043                self.raw_name.as_ref().map(
4044                    <fidl::encoding::Vector<u8, 63> as fidl::encoding::ValueTypeMarker>::borrow,
4045                ),
4046                encoder,
4047                offset + cur_offset,
4048                depth,
4049            )?;
4050
4051            _prev_end_offset = cur_offset + envelope_size;
4052            if 3 > max_ordinal {
4053                return Ok(());
4054            }
4055
4056            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4057            // are envelope_size bytes.
4058            let cur_offset: usize = (3 - 1) * envelope_size;
4059
4060            // Zero reserved fields.
4061            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4062
4063            // Safety:
4064            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4065            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4066            //   envelope_size bytes, there is always sufficient room.
4067            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
4068                self.net_type.as_ref().map(
4069                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
4070                ),
4071                encoder,
4072                offset + cur_offset,
4073                depth,
4074            )?;
4075
4076            _prev_end_offset = cur_offset + envelope_size;
4077            if 4 > max_ordinal {
4078                return Ok(());
4079            }
4080
4081            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4082            // are envelope_size bytes.
4083            let cur_offset: usize = (4 - 1) * envelope_size;
4084
4085            // Zero reserved fields.
4086            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4087
4088            // Safety:
4089            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4090            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4091            //   envelope_size bytes, there is always sufficient room.
4092            fidl::encoding::encode_in_envelope_optional::<u16, D>(
4093                self.channel.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4094                encoder,
4095                offset + cur_offset,
4096                depth,
4097            )?;
4098
4099            _prev_end_offset = cur_offset + envelope_size;
4100            if 5 > max_ordinal {
4101                return Ok(());
4102            }
4103
4104            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4105            // are envelope_size bytes.
4106            let cur_offset: usize = (5 - 1) * envelope_size;
4107
4108            // Zero reserved fields.
4109            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4110
4111            // Safety:
4112            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4113            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4114            //   envelope_size bytes, there is always sufficient room.
4115            fidl::encoding::encode_in_envelope_optional::<u16, D>(
4116                self.panid.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4117                encoder,
4118                offset + cur_offset,
4119                depth,
4120            )?;
4121
4122            _prev_end_offset = cur_offset + envelope_size;
4123            if 6 > max_ordinal {
4124                return Ok(());
4125            }
4126
4127            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4128            // are envelope_size bytes.
4129            let cur_offset: usize = (6 - 1) * envelope_size;
4130
4131            // Zero reserved fields.
4132            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4133
4134            // Safety:
4135            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4136            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4137            //   envelope_size bytes, there is always sufficient room.
4138            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>(
4139            self.mesh_local_prefix.as_ref().map(<fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow),
4140            encoder, offset + cur_offset, depth
4141        )?;
4142
4143            _prev_end_offset = cur_offset + envelope_size;
4144            if 7 > max_ordinal {
4145                return Ok(());
4146            }
4147
4148            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4149            // are envelope_size bytes.
4150            let cur_offset: usize = (7 - 1) * envelope_size;
4151
4152            // Zero reserved fields.
4153            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4154
4155            // Safety:
4156            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4157            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4158            //   envelope_size bytes, there is always sufficient room.
4159            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 8>, D>(
4160                self.xpanid
4161                    .as_ref()
4162                    .map(<fidl::encoding::Array<u8, 8> as fidl::encoding::ValueTypeMarker>::borrow),
4163                encoder,
4164                offset + cur_offset,
4165                depth,
4166            )?;
4167
4168            _prev_end_offset = cur_offset + envelope_size;
4169
4170            Ok(())
4171        }
4172    }
4173
4174    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Identity {
4175        #[inline(always)]
4176        fn new_empty() -> Self {
4177            Self::default()
4178        }
4179
4180        unsafe fn decode(
4181            &mut self,
4182            decoder: &mut fidl::encoding::Decoder<'_, D>,
4183            offset: usize,
4184            mut depth: fidl::encoding::Depth,
4185        ) -> fidl::Result<()> {
4186            decoder.debug_check_bounds::<Self>(offset);
4187            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4188                None => return Err(fidl::Error::NotNullable),
4189                Some(len) => len,
4190            };
4191            // Calling decoder.out_of_line_offset(0) is not allowed.
4192            if len == 0 {
4193                return Ok(());
4194            };
4195            depth.increment()?;
4196            let envelope_size = 8;
4197            let bytes_len = len * envelope_size;
4198            let offset = decoder.out_of_line_offset(bytes_len)?;
4199            // Decode the envelope for each type.
4200            let mut _next_ordinal_to_read = 0;
4201            let mut next_offset = offset;
4202            let end_offset = offset + bytes_len;
4203            _next_ordinal_to_read += 1;
4204            if next_offset >= end_offset {
4205                return Ok(());
4206            }
4207
4208            // Decode unknown envelopes for gaps in ordinals.
4209            while _next_ordinal_to_read < 1 {
4210                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4211                _next_ordinal_to_read += 1;
4212                next_offset += envelope_size;
4213            }
4214
4215            let next_out_of_line = decoder.next_out_of_line();
4216            let handles_before = decoder.remaining_handles();
4217            if let Some((inlined, num_bytes, num_handles)) =
4218                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4219            {
4220                let member_inline_size =
4221                    <fidl::encoding::Vector<u8, 63> as fidl::encoding::TypeMarker>::inline_size(
4222                        decoder.context,
4223                    );
4224                if inlined != (member_inline_size <= 4) {
4225                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4226                }
4227                let inner_offset;
4228                let mut inner_depth = depth.clone();
4229                if inlined {
4230                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4231                    inner_offset = next_offset;
4232                } else {
4233                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4234                    inner_depth.increment()?;
4235                }
4236                let val_ref = self
4237                    .raw_name
4238                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 63>, D));
4239                fidl::decode!(fidl::encoding::Vector<u8, 63>, D, val_ref, decoder, inner_offset, inner_depth)?;
4240                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4241                {
4242                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4243                }
4244                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4245                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4246                }
4247            }
4248
4249            next_offset += envelope_size;
4250            _next_ordinal_to_read += 1;
4251            if next_offset >= end_offset {
4252                return Ok(());
4253            }
4254
4255            // Decode unknown envelopes for gaps in ordinals.
4256            while _next_ordinal_to_read < 3 {
4257                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4258                _next_ordinal_to_read += 1;
4259                next_offset += envelope_size;
4260            }
4261
4262            let next_out_of_line = decoder.next_out_of_line();
4263            let handles_before = decoder.remaining_handles();
4264            if let Some((inlined, num_bytes, num_handles)) =
4265                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4266            {
4267                let member_inline_size =
4268                    <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
4269                        decoder.context,
4270                    );
4271                if inlined != (member_inline_size <= 4) {
4272                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4273                }
4274                let inner_offset;
4275                let mut inner_depth = depth.clone();
4276                if inlined {
4277                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4278                    inner_offset = next_offset;
4279                } else {
4280                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4281                    inner_depth.increment()?;
4282                }
4283                let val_ref = self
4284                    .net_type
4285                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
4286                fidl::decode!(
4287                    fidl::encoding::BoundedString<64>,
4288                    D,
4289                    val_ref,
4290                    decoder,
4291                    inner_offset,
4292                    inner_depth
4293                )?;
4294                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4295                {
4296                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4297                }
4298                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4299                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4300                }
4301            }
4302
4303            next_offset += envelope_size;
4304            _next_ordinal_to_read += 1;
4305            if next_offset >= end_offset {
4306                return Ok(());
4307            }
4308
4309            // Decode unknown envelopes for gaps in ordinals.
4310            while _next_ordinal_to_read < 4 {
4311                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4312                _next_ordinal_to_read += 1;
4313                next_offset += envelope_size;
4314            }
4315
4316            let next_out_of_line = decoder.next_out_of_line();
4317            let handles_before = decoder.remaining_handles();
4318            if let Some((inlined, num_bytes, num_handles)) =
4319                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4320            {
4321                let member_inline_size =
4322                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4323                if inlined != (member_inline_size <= 4) {
4324                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4325                }
4326                let inner_offset;
4327                let mut inner_depth = depth.clone();
4328                if inlined {
4329                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4330                    inner_offset = next_offset;
4331                } else {
4332                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4333                    inner_depth.increment()?;
4334                }
4335                let val_ref = self.channel.get_or_insert_with(|| fidl::new_empty!(u16, D));
4336                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
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 < 5 {
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.panid.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 < 6 {
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 = <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4408                if inlined != (member_inline_size <= 4) {
4409                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4410                }
4411                let inner_offset;
4412                let mut inner_depth = depth.clone();
4413                if inlined {
4414                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4415                    inner_offset = next_offset;
4416                } else {
4417                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4418                    inner_depth.increment()?;
4419                }
4420                let val_ref = self.mesh_local_prefix.get_or_insert_with(|| {
4421                    fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D)
4422                });
4423                fidl::decode!(
4424                    fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
4425                    D,
4426                    val_ref,
4427                    decoder,
4428                    inner_offset,
4429                    inner_depth
4430                )?;
4431                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4432                {
4433                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4434                }
4435                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4436                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4437                }
4438            }
4439
4440            next_offset += envelope_size;
4441            _next_ordinal_to_read += 1;
4442            if next_offset >= end_offset {
4443                return Ok(());
4444            }
4445
4446            // Decode unknown envelopes for gaps in ordinals.
4447            while _next_ordinal_to_read < 7 {
4448                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4449                _next_ordinal_to_read += 1;
4450                next_offset += envelope_size;
4451            }
4452
4453            let next_out_of_line = decoder.next_out_of_line();
4454            let handles_before = decoder.remaining_handles();
4455            if let Some((inlined, num_bytes, num_handles)) =
4456                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4457            {
4458                let member_inline_size =
4459                    <fidl::encoding::Array<u8, 8> as fidl::encoding::TypeMarker>::inline_size(
4460                        decoder.context,
4461                    );
4462                if inlined != (member_inline_size <= 4) {
4463                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4464                }
4465                let inner_offset;
4466                let mut inner_depth = depth.clone();
4467                if inlined {
4468                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4469                    inner_offset = next_offset;
4470                } else {
4471                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4472                    inner_depth.increment()?;
4473                }
4474                let val_ref = self
4475                    .xpanid
4476                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 8>, D));
4477                fidl::decode!(fidl::encoding::Array<u8, 8>, D, val_ref, decoder, inner_offset, inner_depth)?;
4478                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4479                {
4480                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4481                }
4482                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4483                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4484                }
4485            }
4486
4487            next_offset += envelope_size;
4488
4489            // Decode the remaining unknown envelopes.
4490            while next_offset < end_offset {
4491                _next_ordinal_to_read += 1;
4492                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4493                next_offset += envelope_size;
4494            }
4495
4496            Ok(())
4497        }
4498    }
4499
4500    impl IpCounters {
4501        #[inline(always)]
4502        fn max_ordinal_present(&self) -> u64 {
4503            if let Some(_) = self.failure {
4504                return 2;
4505            }
4506            if let Some(_) = self.success {
4507                return 1;
4508            }
4509            0
4510        }
4511    }
4512
4513    impl fidl::encoding::ValueTypeMarker for IpCounters {
4514        type Borrowed<'a> = &'a Self;
4515        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4516            value
4517        }
4518    }
4519
4520    unsafe impl fidl::encoding::TypeMarker for IpCounters {
4521        type Owned = Self;
4522
4523        #[inline(always)]
4524        fn inline_align(_context: fidl::encoding::Context) -> usize {
4525            8
4526        }
4527
4528        #[inline(always)]
4529        fn inline_size(_context: fidl::encoding::Context) -> usize {
4530            16
4531        }
4532    }
4533
4534    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<IpCounters, D>
4535        for &IpCounters
4536    {
4537        unsafe fn encode(
4538            self,
4539            encoder: &mut fidl::encoding::Encoder<'_, D>,
4540            offset: usize,
4541            mut depth: fidl::encoding::Depth,
4542        ) -> fidl::Result<()> {
4543            encoder.debug_check_bounds::<IpCounters>(offset);
4544            // Vector header
4545            let max_ordinal: u64 = self.max_ordinal_present();
4546            encoder.write_num(max_ordinal, offset);
4547            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4548            // Calling encoder.out_of_line_offset(0) is not allowed.
4549            if max_ordinal == 0 {
4550                return Ok(());
4551            }
4552            depth.increment()?;
4553            let envelope_size = 8;
4554            let bytes_len = max_ordinal as usize * envelope_size;
4555            #[allow(unused_variables)]
4556            let offset = encoder.out_of_line_offset(bytes_len);
4557            let mut _prev_end_offset: usize = 0;
4558            if 1 > max_ordinal {
4559                return Ok(());
4560            }
4561
4562            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4563            // are envelope_size bytes.
4564            let cur_offset: usize = (1 - 1) * envelope_size;
4565
4566            // Zero reserved fields.
4567            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4568
4569            // Safety:
4570            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4571            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4572            //   envelope_size bytes, there is always sufficient room.
4573            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4574                self.success.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4575                encoder,
4576                offset + cur_offset,
4577                depth,
4578            )?;
4579
4580            _prev_end_offset = cur_offset + envelope_size;
4581            if 2 > max_ordinal {
4582                return Ok(());
4583            }
4584
4585            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4586            // are envelope_size bytes.
4587            let cur_offset: usize = (2 - 1) * envelope_size;
4588
4589            // Zero reserved fields.
4590            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4591
4592            // Safety:
4593            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4594            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4595            //   envelope_size bytes, there is always sufficient room.
4596            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4597                self.failure.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4598                encoder,
4599                offset + cur_offset,
4600                depth,
4601            )?;
4602
4603            _prev_end_offset = cur_offset + envelope_size;
4604
4605            Ok(())
4606        }
4607    }
4608
4609    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IpCounters {
4610        #[inline(always)]
4611        fn new_empty() -> Self {
4612            Self::default()
4613        }
4614
4615        unsafe fn decode(
4616            &mut self,
4617            decoder: &mut fidl::encoding::Decoder<'_, D>,
4618            offset: usize,
4619            mut depth: fidl::encoding::Depth,
4620        ) -> fidl::Result<()> {
4621            decoder.debug_check_bounds::<Self>(offset);
4622            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4623                None => return Err(fidl::Error::NotNullable),
4624                Some(len) => len,
4625            };
4626            // Calling decoder.out_of_line_offset(0) is not allowed.
4627            if len == 0 {
4628                return Ok(());
4629            };
4630            depth.increment()?;
4631            let envelope_size = 8;
4632            let bytes_len = len * envelope_size;
4633            let offset = decoder.out_of_line_offset(bytes_len)?;
4634            // Decode the envelope for each type.
4635            let mut _next_ordinal_to_read = 0;
4636            let mut next_offset = offset;
4637            let end_offset = offset + bytes_len;
4638            _next_ordinal_to_read += 1;
4639            if next_offset >= end_offset {
4640                return Ok(());
4641            }
4642
4643            // Decode unknown envelopes for gaps in ordinals.
4644            while _next_ordinal_to_read < 1 {
4645                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4646                _next_ordinal_to_read += 1;
4647                next_offset += envelope_size;
4648            }
4649
4650            let next_out_of_line = decoder.next_out_of_line();
4651            let handles_before = decoder.remaining_handles();
4652            if let Some((inlined, num_bytes, num_handles)) =
4653                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4654            {
4655                let member_inline_size =
4656                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4657                if inlined != (member_inline_size <= 4) {
4658                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4659                }
4660                let inner_offset;
4661                let mut inner_depth = depth.clone();
4662                if inlined {
4663                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4664                    inner_offset = next_offset;
4665                } else {
4666                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4667                    inner_depth.increment()?;
4668                }
4669                let val_ref = self.success.get_or_insert_with(|| fidl::new_empty!(u32, D));
4670                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4671                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4672                {
4673                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4674                }
4675                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4676                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4677                }
4678            }
4679
4680            next_offset += envelope_size;
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 < 2 {
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.failure.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
4725            // Decode the remaining unknown envelopes.
4726            while next_offset < end_offset {
4727                _next_ordinal_to_read += 1;
4728                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4729                next_offset += envelope_size;
4730            }
4731
4732            Ok(())
4733        }
4734    }
4735
4736    impl MacCounters {
4737        #[inline(always)]
4738        fn max_ordinal_present(&self) -> u64 {
4739            if let Some(_) = self.err_other {
4740                return 26;
4741            }
4742            if let Some(_) = self.err_busy_channel {
4743                return 25;
4744            }
4745            if let Some(_) = self.err_abort {
4746                return 24;
4747            }
4748            if let Some(_) = self.err_cca {
4749                return 23;
4750            }
4751            if let Some(_) = self.err_fcs {
4752                return 22;
4753            }
4754            if let Some(_) = self.err_sec {
4755                return 21;
4756            }
4757            if let Some(_) = self.err_invalid_src_addr {
4758                return 20;
4759            }
4760            if let Some(_) = self.err_unknown_neighbor {
4761                return 19;
4762            }
4763            if let Some(_) = self.err_no_frame {
4764                return 18;
4765            }
4766            if let Some(_) = self.duplicated {
4767                return 17;
4768            }
4769            if let Some(_) = self.dest_addr_filtered {
4770                return 16;
4771            }
4772            if let Some(_) = self.indirect_max_retry_expiry {
4773                return 15;
4774            }
4775            if let Some(_) = self.direct_max_retry_expiry {
4776                return 14;
4777            }
4778            if let Some(_) = self.retries {
4779                return 13;
4780            }
4781            if let Some(_) = self.address_filtered {
4782                return 12;
4783            }
4784            if let Some(_) = self.other {
4785                return 11;
4786            }
4787            if let Some(_) = self.beacon_request {
4788                return 10;
4789            }
4790            if let Some(_) = self.beacon {
4791                return 9;
4792            }
4793            if let Some(_) = self.data_poll {
4794                return 8;
4795            }
4796            if let Some(_) = self.data {
4797                return 7;
4798            }
4799            if let Some(_) = self.no_ack_requested {
4800                return 6;
4801            }
4802            if let Some(_) = self.acked {
4803                return 5;
4804            }
4805            if let Some(_) = self.ack_requested {
4806                return 4;
4807            }
4808            if let Some(_) = self.broadcast {
4809                return 3;
4810            }
4811            if let Some(_) = self.unicast {
4812                return 2;
4813            }
4814            if let Some(_) = self.total {
4815                return 1;
4816            }
4817            0
4818        }
4819    }
4820
4821    impl fidl::encoding::ValueTypeMarker for MacCounters {
4822        type Borrowed<'a> = &'a Self;
4823        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4824            value
4825        }
4826    }
4827
4828    unsafe impl fidl::encoding::TypeMarker for MacCounters {
4829        type Owned = Self;
4830
4831        #[inline(always)]
4832        fn inline_align(_context: fidl::encoding::Context) -> usize {
4833            8
4834        }
4835
4836        #[inline(always)]
4837        fn inline_size(_context: fidl::encoding::Context) -> usize {
4838            16
4839        }
4840    }
4841
4842    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MacCounters, D>
4843        for &MacCounters
4844    {
4845        unsafe fn encode(
4846            self,
4847            encoder: &mut fidl::encoding::Encoder<'_, D>,
4848            offset: usize,
4849            mut depth: fidl::encoding::Depth,
4850        ) -> fidl::Result<()> {
4851            encoder.debug_check_bounds::<MacCounters>(offset);
4852            // Vector header
4853            let max_ordinal: u64 = self.max_ordinal_present();
4854            encoder.write_num(max_ordinal, offset);
4855            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4856            // Calling encoder.out_of_line_offset(0) is not allowed.
4857            if max_ordinal == 0 {
4858                return Ok(());
4859            }
4860            depth.increment()?;
4861            let envelope_size = 8;
4862            let bytes_len = max_ordinal as usize * envelope_size;
4863            #[allow(unused_variables)]
4864            let offset = encoder.out_of_line_offset(bytes_len);
4865            let mut _prev_end_offset: usize = 0;
4866            if 1 > max_ordinal {
4867                return Ok(());
4868            }
4869
4870            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4871            // are envelope_size bytes.
4872            let cur_offset: usize = (1 - 1) * envelope_size;
4873
4874            // Zero reserved fields.
4875            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4876
4877            // Safety:
4878            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4879            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4880            //   envelope_size bytes, there is always sufficient room.
4881            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4882                self.total.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4883                encoder,
4884                offset + cur_offset,
4885                depth,
4886            )?;
4887
4888            _prev_end_offset = cur_offset + envelope_size;
4889            if 2 > max_ordinal {
4890                return Ok(());
4891            }
4892
4893            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4894            // are envelope_size bytes.
4895            let cur_offset: usize = (2 - 1) * envelope_size;
4896
4897            // Zero reserved fields.
4898            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4899
4900            // Safety:
4901            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4902            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4903            //   envelope_size bytes, there is always sufficient room.
4904            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4905                self.unicast.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4906                encoder,
4907                offset + cur_offset,
4908                depth,
4909            )?;
4910
4911            _prev_end_offset = cur_offset + envelope_size;
4912            if 3 > max_ordinal {
4913                return Ok(());
4914            }
4915
4916            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4917            // are envelope_size bytes.
4918            let cur_offset: usize = (3 - 1) * envelope_size;
4919
4920            // Zero reserved fields.
4921            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4922
4923            // Safety:
4924            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4925            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4926            //   envelope_size bytes, there is always sufficient room.
4927            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4928                self.broadcast.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4929                encoder,
4930                offset + cur_offset,
4931                depth,
4932            )?;
4933
4934            _prev_end_offset = cur_offset + envelope_size;
4935            if 4 > max_ordinal {
4936                return Ok(());
4937            }
4938
4939            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4940            // are envelope_size bytes.
4941            let cur_offset: usize = (4 - 1) * envelope_size;
4942
4943            // Zero reserved fields.
4944            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4945
4946            // Safety:
4947            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4948            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4949            //   envelope_size bytes, there is always sufficient room.
4950            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4951                self.ack_requested.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4952                encoder,
4953                offset + cur_offset,
4954                depth,
4955            )?;
4956
4957            _prev_end_offset = cur_offset + envelope_size;
4958            if 5 > max_ordinal {
4959                return Ok(());
4960            }
4961
4962            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4963            // are envelope_size bytes.
4964            let cur_offset: usize = (5 - 1) * envelope_size;
4965
4966            // Zero reserved fields.
4967            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4968
4969            // Safety:
4970            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4971            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4972            //   envelope_size bytes, there is always sufficient room.
4973            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4974                self.acked.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4975                encoder,
4976                offset + cur_offset,
4977                depth,
4978            )?;
4979
4980            _prev_end_offset = cur_offset + envelope_size;
4981            if 6 > max_ordinal {
4982                return Ok(());
4983            }
4984
4985            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4986            // are envelope_size bytes.
4987            let cur_offset: usize = (6 - 1) * envelope_size;
4988
4989            // Zero reserved fields.
4990            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4991
4992            // Safety:
4993            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4994            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4995            //   envelope_size bytes, there is always sufficient room.
4996            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4997                self.no_ack_requested
4998                    .as_ref()
4999                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5000                encoder,
5001                offset + cur_offset,
5002                depth,
5003            )?;
5004
5005            _prev_end_offset = cur_offset + envelope_size;
5006            if 7 > max_ordinal {
5007                return Ok(());
5008            }
5009
5010            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5011            // are envelope_size bytes.
5012            let cur_offset: usize = (7 - 1) * envelope_size;
5013
5014            // Zero reserved fields.
5015            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5016
5017            // Safety:
5018            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5019            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5020            //   envelope_size bytes, there is always sufficient room.
5021            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5022                self.data.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5023                encoder,
5024                offset + cur_offset,
5025                depth,
5026            )?;
5027
5028            _prev_end_offset = cur_offset + envelope_size;
5029            if 8 > max_ordinal {
5030                return Ok(());
5031            }
5032
5033            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5034            // are envelope_size bytes.
5035            let cur_offset: usize = (8 - 1) * envelope_size;
5036
5037            // Zero reserved fields.
5038            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5039
5040            // Safety:
5041            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5042            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5043            //   envelope_size bytes, there is always sufficient room.
5044            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5045                self.data_poll.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5046                encoder,
5047                offset + cur_offset,
5048                depth,
5049            )?;
5050
5051            _prev_end_offset = cur_offset + envelope_size;
5052            if 9 > max_ordinal {
5053                return Ok(());
5054            }
5055
5056            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5057            // are envelope_size bytes.
5058            let cur_offset: usize = (9 - 1) * envelope_size;
5059
5060            // Zero reserved fields.
5061            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5062
5063            // Safety:
5064            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5065            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5066            //   envelope_size bytes, there is always sufficient room.
5067            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5068                self.beacon.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5069                encoder,
5070                offset + cur_offset,
5071                depth,
5072            )?;
5073
5074            _prev_end_offset = cur_offset + envelope_size;
5075            if 10 > max_ordinal {
5076                return Ok(());
5077            }
5078
5079            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5080            // are envelope_size bytes.
5081            let cur_offset: usize = (10 - 1) * envelope_size;
5082
5083            // Zero reserved fields.
5084            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5085
5086            // Safety:
5087            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5088            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5089            //   envelope_size bytes, there is always sufficient room.
5090            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5091                self.beacon_request.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5092                encoder,
5093                offset + cur_offset,
5094                depth,
5095            )?;
5096
5097            _prev_end_offset = cur_offset + envelope_size;
5098            if 11 > max_ordinal {
5099                return Ok(());
5100            }
5101
5102            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5103            // are envelope_size bytes.
5104            let cur_offset: usize = (11 - 1) * envelope_size;
5105
5106            // Zero reserved fields.
5107            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5108
5109            // Safety:
5110            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5111            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5112            //   envelope_size bytes, there is always sufficient room.
5113            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5114                self.other.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5115                encoder,
5116                offset + cur_offset,
5117                depth,
5118            )?;
5119
5120            _prev_end_offset = cur_offset + envelope_size;
5121            if 12 > max_ordinal {
5122                return Ok(());
5123            }
5124
5125            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5126            // are envelope_size bytes.
5127            let cur_offset: usize = (12 - 1) * envelope_size;
5128
5129            // Zero reserved fields.
5130            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5131
5132            // Safety:
5133            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5134            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5135            //   envelope_size bytes, there is always sufficient room.
5136            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5137                self.address_filtered
5138                    .as_ref()
5139                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5140                encoder,
5141                offset + cur_offset,
5142                depth,
5143            )?;
5144
5145            _prev_end_offset = cur_offset + envelope_size;
5146            if 13 > max_ordinal {
5147                return Ok(());
5148            }
5149
5150            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5151            // are envelope_size bytes.
5152            let cur_offset: usize = (13 - 1) * envelope_size;
5153
5154            // Zero reserved fields.
5155            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5156
5157            // Safety:
5158            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5159            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5160            //   envelope_size bytes, there is always sufficient room.
5161            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5162                self.retries.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5163                encoder,
5164                offset + cur_offset,
5165                depth,
5166            )?;
5167
5168            _prev_end_offset = cur_offset + envelope_size;
5169            if 14 > max_ordinal {
5170                return Ok(());
5171            }
5172
5173            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5174            // are envelope_size bytes.
5175            let cur_offset: usize = (14 - 1) * envelope_size;
5176
5177            // Zero reserved fields.
5178            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5179
5180            // Safety:
5181            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5182            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5183            //   envelope_size bytes, there is always sufficient room.
5184            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5185                self.direct_max_retry_expiry
5186                    .as_ref()
5187                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5188                encoder,
5189                offset + cur_offset,
5190                depth,
5191            )?;
5192
5193            _prev_end_offset = cur_offset + envelope_size;
5194            if 15 > max_ordinal {
5195                return Ok(());
5196            }
5197
5198            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5199            // are envelope_size bytes.
5200            let cur_offset: usize = (15 - 1) * envelope_size;
5201
5202            // Zero reserved fields.
5203            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5204
5205            // Safety:
5206            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5207            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5208            //   envelope_size bytes, there is always sufficient room.
5209            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5210                self.indirect_max_retry_expiry
5211                    .as_ref()
5212                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5213                encoder,
5214                offset + cur_offset,
5215                depth,
5216            )?;
5217
5218            _prev_end_offset = cur_offset + envelope_size;
5219            if 16 > max_ordinal {
5220                return Ok(());
5221            }
5222
5223            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5224            // are envelope_size bytes.
5225            let cur_offset: usize = (16 - 1) * envelope_size;
5226
5227            // Zero reserved fields.
5228            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5229
5230            // Safety:
5231            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5232            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5233            //   envelope_size bytes, there is always sufficient room.
5234            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5235                self.dest_addr_filtered
5236                    .as_ref()
5237                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5238                encoder,
5239                offset + cur_offset,
5240                depth,
5241            )?;
5242
5243            _prev_end_offset = cur_offset + envelope_size;
5244            if 17 > max_ordinal {
5245                return Ok(());
5246            }
5247
5248            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5249            // are envelope_size bytes.
5250            let cur_offset: usize = (17 - 1) * envelope_size;
5251
5252            // Zero reserved fields.
5253            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5254
5255            // Safety:
5256            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5257            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5258            //   envelope_size bytes, there is always sufficient room.
5259            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5260                self.duplicated.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5261                encoder,
5262                offset + cur_offset,
5263                depth,
5264            )?;
5265
5266            _prev_end_offset = cur_offset + envelope_size;
5267            if 18 > max_ordinal {
5268                return Ok(());
5269            }
5270
5271            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5272            // are envelope_size bytes.
5273            let cur_offset: usize = (18 - 1) * envelope_size;
5274
5275            // Zero reserved fields.
5276            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5277
5278            // Safety:
5279            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5280            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5281            //   envelope_size bytes, there is always sufficient room.
5282            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5283                self.err_no_frame.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5284                encoder,
5285                offset + cur_offset,
5286                depth,
5287            )?;
5288
5289            _prev_end_offset = cur_offset + envelope_size;
5290            if 19 > max_ordinal {
5291                return Ok(());
5292            }
5293
5294            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5295            // are envelope_size bytes.
5296            let cur_offset: usize = (19 - 1) * envelope_size;
5297
5298            // Zero reserved fields.
5299            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5300
5301            // Safety:
5302            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5303            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5304            //   envelope_size bytes, there is always sufficient room.
5305            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5306                self.err_unknown_neighbor
5307                    .as_ref()
5308                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5309                encoder,
5310                offset + cur_offset,
5311                depth,
5312            )?;
5313
5314            _prev_end_offset = cur_offset + envelope_size;
5315            if 20 > max_ordinal {
5316                return Ok(());
5317            }
5318
5319            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5320            // are envelope_size bytes.
5321            let cur_offset: usize = (20 - 1) * envelope_size;
5322
5323            // Zero reserved fields.
5324            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5325
5326            // Safety:
5327            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5328            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5329            //   envelope_size bytes, there is always sufficient room.
5330            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5331                self.err_invalid_src_addr
5332                    .as_ref()
5333                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5334                encoder,
5335                offset + cur_offset,
5336                depth,
5337            )?;
5338
5339            _prev_end_offset = cur_offset + envelope_size;
5340            if 21 > max_ordinal {
5341                return Ok(());
5342            }
5343
5344            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5345            // are envelope_size bytes.
5346            let cur_offset: usize = (21 - 1) * envelope_size;
5347
5348            // Zero reserved fields.
5349            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5350
5351            // Safety:
5352            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5353            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5354            //   envelope_size bytes, there is always sufficient room.
5355            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5356                self.err_sec.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5357                encoder,
5358                offset + cur_offset,
5359                depth,
5360            )?;
5361
5362            _prev_end_offset = cur_offset + envelope_size;
5363            if 22 > max_ordinal {
5364                return Ok(());
5365            }
5366
5367            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5368            // are envelope_size bytes.
5369            let cur_offset: usize = (22 - 1) * envelope_size;
5370
5371            // Zero reserved fields.
5372            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5373
5374            // Safety:
5375            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5376            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5377            //   envelope_size bytes, there is always sufficient room.
5378            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5379                self.err_fcs.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5380                encoder,
5381                offset + cur_offset,
5382                depth,
5383            )?;
5384
5385            _prev_end_offset = cur_offset + envelope_size;
5386            if 23 > max_ordinal {
5387                return Ok(());
5388            }
5389
5390            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5391            // are envelope_size bytes.
5392            let cur_offset: usize = (23 - 1) * envelope_size;
5393
5394            // Zero reserved fields.
5395            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5396
5397            // Safety:
5398            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5399            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5400            //   envelope_size bytes, there is always sufficient room.
5401            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5402                self.err_cca.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5403                encoder,
5404                offset + cur_offset,
5405                depth,
5406            )?;
5407
5408            _prev_end_offset = cur_offset + envelope_size;
5409            if 24 > max_ordinal {
5410                return Ok(());
5411            }
5412
5413            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5414            // are envelope_size bytes.
5415            let cur_offset: usize = (24 - 1) * envelope_size;
5416
5417            // Zero reserved fields.
5418            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5419
5420            // Safety:
5421            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5422            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5423            //   envelope_size bytes, there is always sufficient room.
5424            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5425                self.err_abort.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5426                encoder,
5427                offset + cur_offset,
5428                depth,
5429            )?;
5430
5431            _prev_end_offset = cur_offset + envelope_size;
5432            if 25 > max_ordinal {
5433                return Ok(());
5434            }
5435
5436            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5437            // are envelope_size bytes.
5438            let cur_offset: usize = (25 - 1) * envelope_size;
5439
5440            // Zero reserved fields.
5441            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5442
5443            // Safety:
5444            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5445            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5446            //   envelope_size bytes, there is always sufficient room.
5447            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5448                self.err_busy_channel
5449                    .as_ref()
5450                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5451                encoder,
5452                offset + cur_offset,
5453                depth,
5454            )?;
5455
5456            _prev_end_offset = cur_offset + envelope_size;
5457            if 26 > max_ordinal {
5458                return Ok(());
5459            }
5460
5461            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5462            // are envelope_size bytes.
5463            let cur_offset: usize = (26 - 1) * envelope_size;
5464
5465            // Zero reserved fields.
5466            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5467
5468            // Safety:
5469            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5470            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5471            //   envelope_size bytes, there is always sufficient room.
5472            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5473                self.err_other.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5474                encoder,
5475                offset + cur_offset,
5476                depth,
5477            )?;
5478
5479            _prev_end_offset = cur_offset + envelope_size;
5480
5481            Ok(())
5482        }
5483    }
5484
5485    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MacCounters {
5486        #[inline(always)]
5487        fn new_empty() -> Self {
5488            Self::default()
5489        }
5490
5491        unsafe fn decode(
5492            &mut self,
5493            decoder: &mut fidl::encoding::Decoder<'_, D>,
5494            offset: usize,
5495            mut depth: fidl::encoding::Depth,
5496        ) -> fidl::Result<()> {
5497            decoder.debug_check_bounds::<Self>(offset);
5498            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5499                None => return Err(fidl::Error::NotNullable),
5500                Some(len) => len,
5501            };
5502            // Calling decoder.out_of_line_offset(0) is not allowed.
5503            if len == 0 {
5504                return Ok(());
5505            };
5506            depth.increment()?;
5507            let envelope_size = 8;
5508            let bytes_len = len * envelope_size;
5509            let offset = decoder.out_of_line_offset(bytes_len)?;
5510            // Decode the envelope for each type.
5511            let mut _next_ordinal_to_read = 0;
5512            let mut next_offset = offset;
5513            let end_offset = offset + bytes_len;
5514            _next_ordinal_to_read += 1;
5515            if next_offset >= end_offset {
5516                return Ok(());
5517            }
5518
5519            // Decode unknown envelopes for gaps in ordinals.
5520            while _next_ordinal_to_read < 1 {
5521                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5522                _next_ordinal_to_read += 1;
5523                next_offset += envelope_size;
5524            }
5525
5526            let next_out_of_line = decoder.next_out_of_line();
5527            let handles_before = decoder.remaining_handles();
5528            if let Some((inlined, num_bytes, num_handles)) =
5529                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5530            {
5531                let member_inline_size =
5532                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5533                if inlined != (member_inline_size <= 4) {
5534                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5535                }
5536                let inner_offset;
5537                let mut inner_depth = depth.clone();
5538                if inlined {
5539                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5540                    inner_offset = next_offset;
5541                } else {
5542                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5543                    inner_depth.increment()?;
5544                }
5545                let val_ref = self.total.get_or_insert_with(|| fidl::new_empty!(u32, D));
5546                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
5547                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5548                {
5549                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5550                }
5551                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5552                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5553                }
5554            }
5555
5556            next_offset += envelope_size;
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 < 2 {
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.unicast.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 < 3 {
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.broadcast.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 < 4 {
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.ack_requested.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 < 5 {
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.acked.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 < 6 {
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.no_ack_requested.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 < 7 {
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.data.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 < 8 {
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_poll.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 < 9 {
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.beacon.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 < 10 {
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_request.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 < 11 {
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.other.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 < 12 {
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.address_filtered.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 < 13 {
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.retries.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 < 14 {
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 =
6105                    self.direct_max_retry_expiry.get_or_insert_with(|| fidl::new_empty!(u32, D));
6106                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6107                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6108                {
6109                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6110                }
6111                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6112                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6113                }
6114            }
6115
6116            next_offset += envelope_size;
6117            _next_ordinal_to_read += 1;
6118            if next_offset >= end_offset {
6119                return Ok(());
6120            }
6121
6122            // Decode unknown envelopes for gaps in ordinals.
6123            while _next_ordinal_to_read < 15 {
6124                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6125                _next_ordinal_to_read += 1;
6126                next_offset += envelope_size;
6127            }
6128
6129            let next_out_of_line = decoder.next_out_of_line();
6130            let handles_before = decoder.remaining_handles();
6131            if let Some((inlined, num_bytes, num_handles)) =
6132                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6133            {
6134                let member_inline_size =
6135                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6136                if inlined != (member_inline_size <= 4) {
6137                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6138                }
6139                let inner_offset;
6140                let mut inner_depth = depth.clone();
6141                if inlined {
6142                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6143                    inner_offset = next_offset;
6144                } else {
6145                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6146                    inner_depth.increment()?;
6147                }
6148                let val_ref =
6149                    self.indirect_max_retry_expiry.get_or_insert_with(|| fidl::new_empty!(u32, D));
6150                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6151                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6152                {
6153                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6154                }
6155                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6156                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6157                }
6158            }
6159
6160            next_offset += envelope_size;
6161            _next_ordinal_to_read += 1;
6162            if next_offset >= end_offset {
6163                return Ok(());
6164            }
6165
6166            // Decode unknown envelopes for gaps in ordinals.
6167            while _next_ordinal_to_read < 16 {
6168                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6169                _next_ordinal_to_read += 1;
6170                next_offset += envelope_size;
6171            }
6172
6173            let next_out_of_line = decoder.next_out_of_line();
6174            let handles_before = decoder.remaining_handles();
6175            if let Some((inlined, num_bytes, num_handles)) =
6176                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6177            {
6178                let member_inline_size =
6179                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6180                if inlined != (member_inline_size <= 4) {
6181                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6182                }
6183                let inner_offset;
6184                let mut inner_depth = depth.clone();
6185                if inlined {
6186                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6187                    inner_offset = next_offset;
6188                } else {
6189                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6190                    inner_depth.increment()?;
6191                }
6192                let val_ref =
6193                    self.dest_addr_filtered.get_or_insert_with(|| fidl::new_empty!(u32, D));
6194                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6195                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6196                {
6197                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6198                }
6199                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6200                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6201                }
6202            }
6203
6204            next_offset += envelope_size;
6205            _next_ordinal_to_read += 1;
6206            if next_offset >= end_offset {
6207                return Ok(());
6208            }
6209
6210            // Decode unknown envelopes for gaps in ordinals.
6211            while _next_ordinal_to_read < 17 {
6212                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6213                _next_ordinal_to_read += 1;
6214                next_offset += envelope_size;
6215            }
6216
6217            let next_out_of_line = decoder.next_out_of_line();
6218            let handles_before = decoder.remaining_handles();
6219            if let Some((inlined, num_bytes, num_handles)) =
6220                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6221            {
6222                let member_inline_size =
6223                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6224                if inlined != (member_inline_size <= 4) {
6225                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6226                }
6227                let inner_offset;
6228                let mut inner_depth = depth.clone();
6229                if inlined {
6230                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6231                    inner_offset = next_offset;
6232                } else {
6233                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6234                    inner_depth.increment()?;
6235                }
6236                let val_ref = self.duplicated.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 < 18 {
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.err_no_frame.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 < 19 {
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 =
6323                    self.err_unknown_neighbor.get_or_insert_with(|| fidl::new_empty!(u32, D));
6324                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6325                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6326                {
6327                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6328                }
6329                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6330                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6331                }
6332            }
6333
6334            next_offset += envelope_size;
6335            _next_ordinal_to_read += 1;
6336            if next_offset >= end_offset {
6337                return Ok(());
6338            }
6339
6340            // Decode unknown envelopes for gaps in ordinals.
6341            while _next_ordinal_to_read < 20 {
6342                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6343                _next_ordinal_to_read += 1;
6344                next_offset += envelope_size;
6345            }
6346
6347            let next_out_of_line = decoder.next_out_of_line();
6348            let handles_before = decoder.remaining_handles();
6349            if let Some((inlined, num_bytes, num_handles)) =
6350                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6351            {
6352                let member_inline_size =
6353                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6354                if inlined != (member_inline_size <= 4) {
6355                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6356                }
6357                let inner_offset;
6358                let mut inner_depth = depth.clone();
6359                if inlined {
6360                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6361                    inner_offset = next_offset;
6362                } else {
6363                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6364                    inner_depth.increment()?;
6365                }
6366                let val_ref =
6367                    self.err_invalid_src_addr.get_or_insert_with(|| fidl::new_empty!(u32, D));
6368                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6369                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6370                {
6371                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6372                }
6373                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6374                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6375                }
6376            }
6377
6378            next_offset += envelope_size;
6379            _next_ordinal_to_read += 1;
6380            if next_offset >= end_offset {
6381                return Ok(());
6382            }
6383
6384            // Decode unknown envelopes for gaps in ordinals.
6385            while _next_ordinal_to_read < 21 {
6386                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6387                _next_ordinal_to_read += 1;
6388                next_offset += envelope_size;
6389            }
6390
6391            let next_out_of_line = decoder.next_out_of_line();
6392            let handles_before = decoder.remaining_handles();
6393            if let Some((inlined, num_bytes, num_handles)) =
6394                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6395            {
6396                let member_inline_size =
6397                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6398                if inlined != (member_inline_size <= 4) {
6399                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6400                }
6401                let inner_offset;
6402                let mut inner_depth = depth.clone();
6403                if inlined {
6404                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6405                    inner_offset = next_offset;
6406                } else {
6407                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6408                    inner_depth.increment()?;
6409                }
6410                let val_ref = self.err_sec.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 < 22 {
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_fcs.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 < 23 {
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_cca.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 < 24 {
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_abort.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 < 25 {
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_busy_channel.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 < 26 {
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_other.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
6638            // Decode the remaining unknown envelopes.
6639            while next_offset < end_offset {
6640                _next_ordinal_to_read += 1;
6641                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6642                next_offset += envelope_size;
6643            }
6644
6645            Ok(())
6646        }
6647    }
6648
6649    impl fidl::encoding::ValueTypeMarker for Credential {
6650        type Borrowed<'a> = &'a Self;
6651        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6652            value
6653        }
6654    }
6655
6656    unsafe impl fidl::encoding::TypeMarker for Credential {
6657        type Owned = Self;
6658
6659        #[inline(always)]
6660        fn inline_align(_context: fidl::encoding::Context) -> usize {
6661            8
6662        }
6663
6664        #[inline(always)]
6665        fn inline_size(_context: fidl::encoding::Context) -> usize {
6666            16
6667        }
6668    }
6669
6670    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Credential, D>
6671        for &Credential
6672    {
6673        #[inline]
6674        unsafe fn encode(
6675            self,
6676            encoder: &mut fidl::encoding::Encoder<'_, D>,
6677            offset: usize,
6678            _depth: fidl::encoding::Depth,
6679        ) -> fidl::Result<()> {
6680            encoder.debug_check_bounds::<Credential>(offset);
6681            encoder.write_num::<u64>(self.ordinal(), offset);
6682            match self {
6683                Credential::NetworkKey(ref val) => {
6684                    fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<u8, 32>, D>(
6685                        <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow(
6686                            val,
6687                        ),
6688                        encoder,
6689                        offset + 8,
6690                        _depth,
6691                    )
6692                }
6693                Credential::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
6694            }
6695        }
6696    }
6697
6698    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Credential {
6699        #[inline(always)]
6700        fn new_empty() -> Self {
6701            Self::__SourceBreaking { unknown_ordinal: 0 }
6702        }
6703
6704        #[inline]
6705        unsafe fn decode(
6706            &mut self,
6707            decoder: &mut fidl::encoding::Decoder<'_, D>,
6708            offset: usize,
6709            mut depth: fidl::encoding::Depth,
6710        ) -> fidl::Result<()> {
6711            decoder.debug_check_bounds::<Self>(offset);
6712            #[allow(unused_variables)]
6713            let next_out_of_line = decoder.next_out_of_line();
6714            let handles_before = decoder.remaining_handles();
6715            let (ordinal, inlined, num_bytes, num_handles) =
6716                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
6717
6718            let member_inline_size = match ordinal {
6719                1 => <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
6720                    decoder.context,
6721                ),
6722                0 => return Err(fidl::Error::UnknownUnionTag),
6723                _ => num_bytes as usize,
6724            };
6725
6726            if inlined != (member_inline_size <= 4) {
6727                return Err(fidl::Error::InvalidInlineBitInEnvelope);
6728            }
6729            let _inner_offset;
6730            if inlined {
6731                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
6732                _inner_offset = offset + 8;
6733            } else {
6734                depth.increment()?;
6735                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6736            }
6737            match ordinal {
6738                1 => {
6739                    #[allow(irrefutable_let_patterns)]
6740                    if let Credential::NetworkKey(_) = self {
6741                        // Do nothing, read the value into the object
6742                    } else {
6743                        // Initialize `self` to the right variant
6744                        *self = Credential::NetworkKey(
6745                            fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D),
6746                        );
6747                    }
6748                    #[allow(irrefutable_let_patterns)]
6749                    if let Credential::NetworkKey(ref mut val) = self {
6750                        fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val, decoder, _inner_offset, depth)?;
6751                    } else {
6752                        unreachable!()
6753                    }
6754                }
6755                #[allow(deprecated)]
6756                ordinal => {
6757                    for _ in 0..num_handles {
6758                        decoder.drop_next_handle()?;
6759                    }
6760                    *self = Credential::__SourceBreaking { unknown_ordinal: ordinal };
6761                }
6762            }
6763            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
6764                return Err(fidl::Error::InvalidNumBytesInEnvelope);
6765            }
6766            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6767                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6768            }
6769            Ok(())
6770        }
6771    }
6772}