fidl_fuchsia_lowpan_experimental__common/
fidl_fuchsia_lowpan_experimental__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
11pub const MAX_EXTERNAL_ROUTES: u32 = 32;
12
13pub const MAX_ON_MESH_PREFIXES: u32 = 32;
14
15pub const MAX_PROVISION_URL_LEN: u16 = 64;
16
17pub const MAX_VENDOR_DATA_LEN: u16 = 64;
18
19pub const MAX_VENDOR_MODEL_LEN: u16 = 32;
20
21pub const MAX_VENDOR_NAME_LEN: u16 = 32;
22
23pub const MAX_VENDOR_SW_VER_LEN: u16 = 16;
24
25pub const PSKD_LEN: u16 = 32;
26
27/// Represents the DHCPv6 PD state.
28#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
29pub enum Dhcp6PdState {
30    Dhcp6PdStateUnspecified,
31    /// DHCPv6 PD is disabled on the border router.
32    Dhcp6PdStateDisabled,
33    /// DHCPv6 PD is enabled but won't try to request and publish a prefix.
34    Dhcp6PdStateStopped,
35    /// DHCPv6 PD is enabled and will try to request and publish a prefix.
36    Dhcp6PdStateRunning,
37    /// DHCPv6 PD is idle; Higher-prf prefix published by other BRs.
38    Dhcp6PdStateIdle,
39    #[doc(hidden)]
40    __SourceBreaking {
41        unknown_ordinal: u32,
42    },
43}
44
45/// Pattern that matches an unknown `Dhcp6PdState` member.
46#[macro_export]
47macro_rules! Dhcp6PdStateUnknown {
48    () => {
49        _
50    };
51}
52
53impl Dhcp6PdState {
54    #[inline]
55    pub fn from_primitive(prim: u32) -> Option<Self> {
56        match prim {
57            0 => Some(Self::Dhcp6PdStateUnspecified),
58            1 => Some(Self::Dhcp6PdStateDisabled),
59            2 => Some(Self::Dhcp6PdStateStopped),
60            3 => Some(Self::Dhcp6PdStateRunning),
61            4 => Some(Self::Dhcp6PdStateIdle),
62            _ => None,
63        }
64    }
65
66    #[inline]
67    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
68        match prim {
69            0 => Self::Dhcp6PdStateUnspecified,
70            1 => Self::Dhcp6PdStateDisabled,
71            2 => Self::Dhcp6PdStateStopped,
72            3 => Self::Dhcp6PdStateRunning,
73            4 => Self::Dhcp6PdStateIdle,
74            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
75        }
76    }
77
78    #[inline]
79    pub fn unknown() -> Self {
80        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
81    }
82
83    #[inline]
84    pub const fn into_primitive(self) -> u32 {
85        match self {
86            Self::Dhcp6PdStateUnspecified => 0,
87            Self::Dhcp6PdStateDisabled => 1,
88            Self::Dhcp6PdStateStopped => 2,
89            Self::Dhcp6PdStateRunning => 3,
90            Self::Dhcp6PdStateIdle => 4,
91            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
92        }
93    }
94
95    #[inline]
96    pub fn is_unknown(&self) -> bool {
97        match self {
98            Self::__SourceBreaking { unknown_ordinal: _ } => true,
99            _ => false,
100        }
101    }
102}
103
104#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
105pub enum Nat64State {
106    Nat64StateUnspecified,
107    Nat64StateDisabled,
108    Nat64StateNotRunning,
109    Nat64StateIdle,
110    Nat64StateActive,
111    #[doc(hidden)]
112    __SourceBreaking {
113        unknown_ordinal: u32,
114    },
115}
116
117/// Pattern that matches an unknown `Nat64State` member.
118#[macro_export]
119macro_rules! Nat64StateUnknown {
120    () => {
121        _
122    };
123}
124
125impl Nat64State {
126    #[inline]
127    pub fn from_primitive(prim: u32) -> Option<Self> {
128        match prim {
129            0 => Some(Self::Nat64StateUnspecified),
130            1 => Some(Self::Nat64StateDisabled),
131            2 => Some(Self::Nat64StateNotRunning),
132            3 => Some(Self::Nat64StateIdle),
133            4 => Some(Self::Nat64StateActive),
134            _ => None,
135        }
136    }
137
138    #[inline]
139    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
140        match prim {
141            0 => Self::Nat64StateUnspecified,
142            1 => Self::Nat64StateDisabled,
143            2 => Self::Nat64StateNotRunning,
144            3 => Self::Nat64StateIdle,
145            4 => Self::Nat64StateActive,
146            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
147        }
148    }
149
150    #[inline]
151    pub fn unknown() -> Self {
152        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
153    }
154
155    #[inline]
156    pub const fn into_primitive(self) -> u32 {
157        match self {
158            Self::Nat64StateUnspecified => 0,
159            Self::Nat64StateDisabled => 1,
160            Self::Nat64StateNotRunning => 2,
161            Self::Nat64StateIdle => 3,
162            Self::Nat64StateActive => 4,
163            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
164        }
165    }
166
167    #[inline]
168    pub fn is_unknown(&self) -> bool {
169        match self {
170            Self::__SourceBreaking { unknown_ordinal: _ } => true,
171            _ => false,
172        }
173    }
174}
175
176/// LoWPAN Provisioning Error
177///
178/// Returned by [`ProvisioningMonitor.WatchProgress`].
179#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
180pub enum ProvisionError {
181    /// Provisioning did not successfully complete because the
182    /// credential was rejected. For example, the key was incorrect.
183    ///
184    /// This may be interpreted as an argument error.
185    CredentialRejected,
186    /// Provisioning did not successfully complete because the
187    /// no peers on the requested network are in range.
188    NetworkNotFound,
189    /// Forming a new network did not successfully complete because the
190    /// a peer with the requested network identity is in range.
191    NetworkAlreadyExists,
192    /// This operation was canceled due to an incompatible operation
193    /// being started before this one was finished.
194    Canceled,
195    #[doc(hidden)]
196    __SourceBreaking { unknown_ordinal: i32 },
197}
198
199/// Pattern that matches an unknown `ProvisionError` member.
200#[macro_export]
201macro_rules! ProvisionErrorUnknown {
202    () => {
203        _
204    };
205}
206
207impl ProvisionError {
208    #[inline]
209    pub fn from_primitive(prim: i32) -> Option<Self> {
210        match prim {
211            1 => Some(Self::CredentialRejected),
212            2 => Some(Self::NetworkNotFound),
213            3 => Some(Self::NetworkAlreadyExists),
214            4 => Some(Self::Canceled),
215            _ => None,
216        }
217    }
218
219    #[inline]
220    pub fn from_primitive_allow_unknown(prim: i32) -> Self {
221        match prim {
222            1 => Self::CredentialRejected,
223            2 => Self::NetworkNotFound,
224            3 => Self::NetworkAlreadyExists,
225            4 => Self::Canceled,
226            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
227        }
228    }
229
230    #[inline]
231    pub fn unknown() -> Self {
232        Self::__SourceBreaking { unknown_ordinal: 0x7fffffff }
233    }
234
235    #[inline]
236    pub const fn into_primitive(self) -> i32 {
237        match self {
238            Self::CredentialRejected => 1,
239            Self::NetworkNotFound => 2,
240            Self::NetworkAlreadyExists => 3,
241            Self::Canceled => 4,
242            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
243        }
244    }
245
246    #[inline]
247    pub fn is_unknown(&self) -> bool {
248        match self {
249            Self::__SourceBreaking { unknown_ordinal: _ } => true,
250            _ => false,
251        }
252    }
253}
254
255/// Route preference, as described in RFC4191.
256#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
257#[repr(i8)]
258pub enum RoutePreference {
259    /// Low route preference.
260    Low = -1,
261    /// Medium route preference.
262    Medium = 0,
263    /// High route preference.
264    High = 1,
265}
266
267impl RoutePreference {
268    #[inline]
269    pub fn from_primitive(prim: i8) -> Option<Self> {
270        match prim {
271            -1 => Some(Self::Low),
272            0 => Some(Self::Medium),
273            1 => Some(Self::High),
274            _ => None,
275        }
276    }
277
278    #[inline]
279    pub const fn into_primitive(self) -> i8 {
280        self as i8
281    }
282}
283
284#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
285#[repr(u32)]
286pub enum SrpServerAddressMode {
287    /// Thread network data is published as unicast addresses.
288    Unicast = 1,
289    /// Thread network data is published as anycast addresses.
290    Anycast = 2,
291}
292
293impl SrpServerAddressMode {
294    #[inline]
295    pub fn from_primitive(prim: u32) -> Option<Self> {
296        match prim {
297            1 => Some(Self::Unicast),
298            2 => Some(Self::Anycast),
299            _ => None,
300        }
301    }
302
303    #[inline]
304    pub const fn into_primitive(self) -> u32 {
305        self as u32
306    }
307}
308
309#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
310#[repr(u32)]
311pub enum SrpServerState {
312    /// The server is disabled.
313    Disabled = 1,
314    /// The server is enabled and running.
315    Running = 2,
316    /// The server is enabled, but stopped.
317    Stopped = 3,
318}
319
320impl SrpServerState {
321    #[inline]
322    pub fn from_primitive(prim: u32) -> Option<Self> {
323        match prim {
324            1 => Some(Self::Disabled),
325            2 => Some(Self::Running),
326            3 => Some(Self::Stopped),
327            _ => None,
328        }
329    }
330
331    #[inline]
332    pub const fn into_primitive(self) -> u32 {
333        self as u32
334    }
335}
336
337/// Represents the Upstream DNS state
338#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
339pub enum UpstreamDnsQueryState {
340    UpstreamdnsQueryStateUnspecified,
341    UpstreamdnsQueryStateEnabled,
342    UpstreamdnsQueryStateDisabled,
343    #[doc(hidden)]
344    __SourceBreaking {
345        unknown_ordinal: u32,
346    },
347}
348
349/// Pattern that matches an unknown `UpstreamDnsQueryState` member.
350#[macro_export]
351macro_rules! UpstreamDnsQueryStateUnknown {
352    () => {
353        _
354    };
355}
356
357impl UpstreamDnsQueryState {
358    #[inline]
359    pub fn from_primitive(prim: u32) -> Option<Self> {
360        match prim {
361            0 => Some(Self::UpstreamdnsQueryStateUnspecified),
362            1 => Some(Self::UpstreamdnsQueryStateEnabled),
363            2 => Some(Self::UpstreamdnsQueryStateDisabled),
364            _ => None,
365        }
366    }
367
368    #[inline]
369    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
370        match prim {
371            0 => Self::UpstreamdnsQueryStateUnspecified,
372            1 => Self::UpstreamdnsQueryStateEnabled,
373            2 => Self::UpstreamdnsQueryStateDisabled,
374            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
375        }
376    }
377
378    #[inline]
379    pub fn unknown() -> Self {
380        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
381    }
382
383    #[inline]
384    pub const fn into_primitive(self) -> u32 {
385        match self {
386            Self::UpstreamdnsQueryStateUnspecified => 0,
387            Self::UpstreamdnsQueryStateEnabled => 1,
388            Self::UpstreamdnsQueryStateDisabled => 2,
389            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
390        }
391    }
392
393    #[inline]
394    pub fn is_unknown(&self) -> bool {
395        match self {
396            Self::__SourceBreaking { unknown_ordinal: _ } => true,
397            _ => false,
398        }
399    }
400}
401
402#[derive(Clone, Debug, PartialEq)]
403pub struct BeaconInfoStreamNextResponse {
404    pub beacons: Vec<BeaconInfo>,
405}
406
407impl fidl::Persistable for BeaconInfoStreamNextResponse {}
408
409#[derive(Clone, Debug, PartialEq)]
410pub struct DeviceGetSupportedChannelsResponse {
411    pub channels_info: Vec<ChannelInfo>,
412}
413
414impl fidl::Persistable for DeviceGetSupportedChannelsResponse {}
415
416#[derive(Clone, Debug, PartialEq)]
417pub struct DeviceRouteExtraGetLocalExternalRoutesResponse {
418    pub external_routes: Vec<ExternalRoute>,
419}
420
421impl fidl::Persistable for DeviceRouteExtraGetLocalExternalRoutesResponse {}
422
423#[derive(Clone, Debug, PartialEq)]
424pub struct DeviceRouteExtraGetLocalOnMeshPrefixesResponse {
425    pub prefixes: Vec<OnMeshPrefix>,
426}
427
428impl fidl::Persistable for DeviceRouteExtraGetLocalOnMeshPrefixesResponse {}
429
430#[derive(Clone, Debug, PartialEq)]
431pub struct DeviceRouteRegisterExternalRouteRequest {
432    pub external_route: ExternalRoute,
433}
434
435impl fidl::Persistable for DeviceRouteRegisterExternalRouteRequest {}
436
437#[derive(Clone, Debug, PartialEq)]
438pub struct DeviceRouteRegisterOnMeshPrefixRequest {
439    pub prefix: OnMeshPrefix,
440}
441
442impl fidl::Persistable for DeviceRouteRegisterOnMeshPrefixRequest {}
443
444#[derive(Clone, Debug, PartialEq)]
445pub struct DeviceRouteUnregisterExternalRouteRequest {
446    pub subnet: fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
447}
448
449impl fidl::Persistable for DeviceRouteUnregisterExternalRouteRequest {}
450
451#[derive(Clone, Debug, PartialEq)]
452pub struct DeviceRouteUnregisterOnMeshPrefixRequest {
453    pub subnet: fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
454}
455
456impl fidl::Persistable for DeviceRouteUnregisterOnMeshPrefixRequest {}
457
458#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
459#[repr(C)]
460pub struct LegacyJoiningMakeJoinableRequest {
461    pub duration: i64,
462    pub port: u16,
463}
464
465impl fidl::Persistable for LegacyJoiningMakeJoinableRequest {}
466
467#[derive(Clone, Debug, PartialEq)]
468pub struct ProvisioningMonitorWatchProgressResponse {
469    pub progress: ProvisioningProgress,
470}
471
472impl fidl::Persistable for ProvisioningMonitorWatchProgressResponse {}
473
474#[derive(Clone, Debug, PartialEq)]
475pub struct TelemetryProviderGetTelemetryResponse {
476    pub telemetry: Telemetry,
477}
478
479impl fidl::Persistable for TelemetryProviderGetTelemetryResponse {}
480
481#[derive(Clone, Debug, Default, PartialEq)]
482pub struct BeaconInfo {
483    /// The MAC address associated with this beacon.
484    pub address: Option<fidl_fuchsia_lowpan__common::MacAddress>,
485    /// The identity of the network being advertised by
486    /// this beacon.
487    pub identity: Option<fidl_fuchsia_lowpan_device__common::Identity>,
488    /// RSSI of the beacon, measured in dBm.
489    ///
490    /// A value of -128 should be treated as if this
491    /// field was absent.
492    pub rssi: Option<i8>,
493    /// Link Quality Index (LQI) of the beacon.
494    ///
495    /// * A value of 0 should be treated as if this
496    ///   field was absent.
497    /// * A value of 1 indicates the worst possible
498    ///   quality where the decoded beacon is still valid.
499    /// * A value of 255 indicates the best possible
500    ///   quality that can be recognized by the radio
501    ///   hardware.
502    /// * Values 2-254 are intended to represent relative
503    ///   quality levels evenly distributed between the
504    ///   worst and best, with lower values always
505    ///   indicating a worse quality than higher values.
506    pub lqi: Option<u8>,
507    #[doc(hidden)]
508    pub __source_breaking: fidl::marker::SourceBreaking,
509}
510
511impl fidl::Persistable for BeaconInfo {}
512
513/// Counters associated with border routing.
514#[derive(Clone, Debug, Default, PartialEq)]
515pub struct BorderRoutingCounters {
516    /// The number of packets associated with inbound unicast messages.
517    ///
518    /// Required.
519    pub inbound_unicast_packets: Option<u64>,
520    /// The number of bytes associated with inbound unicast messages.
521    ///
522    /// Required.
523    pub inbound_unicast_bytes: Option<u64>,
524    /// The number of packets associated with inbound multicast messages.
525    ///
526    /// Required.
527    pub inbound_multicast_packets: Option<u64>,
528    /// The number of bytes associated with inbound multicast messages.
529    ///
530    /// Required.
531    pub inbound_multicast_bytes: Option<u64>,
532    /// The number of packets associated with outbound unicast messages.
533    ///
534    /// Required.
535    pub outbound_unicast_packets: Option<u64>,
536    /// The number of bytes associated with outbound unicast messages.
537    ///
538    /// Required.
539    pub outbound_unicast_bytes: Option<u64>,
540    /// The number of packets associated with outbound multicast messages.
541    ///
542    /// Required.
543    pub outbound_multicast_packets: Option<u64>,
544    /// The number of bytes associated with outbound multicast messages.
545    ///
546    /// Required.
547    pub outbound_multicast_bytes: Option<u64>,
548    /// The number of received RA packets.
549    ///
550    /// Required.
551    pub ra_rx: Option<u32>,
552    /// The number of RA packets successfully transmitted.
553    ///
554    /// Required.
555    pub ra_tx_success: Option<u32>,
556    /// The number of RA packets failed to transmit.
557    ///
558    /// Required.
559    pub ra_tx_failure: Option<u32>,
560    /// The number of received RS packets.
561    ///
562    /// Required.
563    pub rs_rx: Option<u32>,
564    /// The number of RS packets successfully transmitted.
565    ///
566    /// Required.
567    pub rs_tx_success: Option<u32>,
568    /// The number of RS packets failed to transmit.
569    ///
570    /// Required.
571    pub rs_tx_failure: Option<u32>,
572    /// Inbound Internet packets when DHCPv6 PD enabled.
573    ///
574    /// Optional.
575    pub inbound_internet_packets: Option<u64>,
576    /// Inbound Internet bytes when DHCPv6 PD enabled.
577    ///
578    /// Optional.
579    pub inbound_internet_bytes: Option<u64>,
580    /// Outbound Internet packets when DHCPv6 PD enabled.
581    ///
582    /// Optional.
583    pub outbound_internet_packets: Option<u64>,
584    /// Outbound Internet bytes when DHCPv6 PD enabled.
585    ///
586    /// Optional.
587    pub outbound_internet_bytes: Option<u64>,
588    #[doc(hidden)]
589    pub __source_breaking: fidl::marker::SourceBreaking,
590}
591
592impl fidl::Persistable for BorderRoutingCounters {}
593
594/// Information about the state of components of NAT64
595#[derive(Clone, Debug, Default, PartialEq)]
596pub struct BorderRoutingNat64State {
597    /// prefix manager state
598    pub prefix_manager_state: Option<Nat64State>,
599    /// translator state
600    pub translator_state: Option<Nat64State>,
601    #[doc(hidden)]
602    pub __source_breaking: fidl::marker::SourceBreaking,
603}
604
605impl fidl::Persistable for BorderRoutingNat64State {}
606
607#[derive(Clone, Debug, Default, PartialEq)]
608pub struct ChannelInfo {
609    /// The index used by the interface to identify
610    /// this channel.
611    pub index: Option<u16>,
612    /// Human-readable identifier for channel.
613    ///
614    /// For most network types, this is just
615    /// the string representation of the index.
616    /// However, some network types might have
617    /// non-integer ways of identifying specific
618    /// channels. This field allows the application
619    /// to display the name of the channel correctly
620    /// under such circumstances.
621    ///
622    /// The allowed characters include:
623    ///
624    ///  * Dash (`-`), Underscore (`_`), Plus(`+`), Semicolon(`:`)
625    ///  * Numbers (`0`-`9`)
626    ///  * Letters (`a`-`z`, `A`-`Z`)
627    pub id: Option<String>,
628    /// The maximum transmit power allowed on
629    /// this channel, in dBm.
630    pub max_transmit_power_dbm: Option<i8>,
631    /// The center RF frequency of this channel, in Hz.
632    ///
633    /// For example, 802.15.4 has the following values:
634    ///
635    /// Channel | Center Frequency (Hz)
636    /// --------|----------------------
637    /// 11      | 2,405,000,000
638    /// 12      | 2,410,000,000
639    /// 13      | 2,415,000,000
640    /// 14      | 2,420,000,000
641    /// 15      | 2,425,000,000
642    /// 16      | 2,430,000,000
643    /// 17      | 2,435,000,000
644    /// 18      | 2,440,000,000
645    /// 19      | 2,445,000,000
646    /// 20      | 2,450,000,000
647    /// 21      | 2,455,000,000
648    /// 22      | 2,460,000,000
649    /// 23      | 2,465,000,000
650    /// 24      | 2,470,000,000
651    /// 25      | 2,475,000,000
652    /// 26      | 2,480,000,000
653    pub spectrum_center_frequency_hz: Option<u64>,
654    /// The RF spectrum bandwidth used by this
655    /// channel where the power level is expected to
656    /// be higher than -20dBr, in Hz.
657    ///
658    /// For example, 802.15.4 channels 11 thru 26 would
659    /// have the value 2,000,000 (2 MHz).
660    pub spectrum_bandwidth_hz: Option<u64>,
661    /// Indicates if this channel is masked by the
662    /// current regulatory domain and is thus unable
663    /// to be used.
664    pub masked_by_regulatory_domain: Option<bool>,
665    #[doc(hidden)]
666    pub __source_breaking: fidl::marker::SourceBreaking,
667}
668
669impl fidl::Persistable for ChannelInfo {}
670
671/// DHCPv6 PD related info.
672#[derive(Clone, Debug, Default, PartialEq)]
673pub struct Dhcp6PdInfo {
674    /// DHCPv6 PD state.
675    ///
676    /// Required.
677    pub dhcp6pd_state: Option<Dhcp6PdState>,
678    /// DHCPv6 PD processed RA Info.
679    ///
680    /// Optional.
681    pub pd_processed_ra_info: Option<PdProcessedRaInfo>,
682    /// DHCPv6 PD prefix.
683    ///
684    /// Optional.
685    pub hashed_pd_prefix: Option<Vec<u8>>,
686    #[doc(hidden)]
687    pub __source_breaking: fidl::marker::SourceBreaking,
688}
689
690impl fidl::Persistable for Dhcp6PdInfo {}
691
692/// Counters associated with the DNS-SD server.
693#[derive(Clone, Debug, Default, PartialEq)]
694pub struct DnssdCounters {
695    /// The number of successful responses.
696    ///
697    /// Required.
698    pub success_response: Option<u32>,
699    /// The number of 'server failure' responses.
700    ///
701    /// Required.
702    pub server_failure_response: Option<u32>,
703    /// The number of 'format error' responses.
704    ///
705    /// Required.
706    pub format_error_response: Option<u32>,
707    /// The number of 'name error' responses.
708    ///
709    /// Required.
710    pub name_error_response: Option<u32>,
711    /// The number of 'not implemented' responses.
712    ///
713    /// Required.
714    pub not_implemented_response: Option<u32>,
715    /// The number of 'other' responses.
716    ///
717    /// Required.
718    pub other_response: Option<u32>,
719    /// The number of queries completely resolved by the local SRP server.
720    ///
721    /// Required.
722    pub resolved_by_srp: Option<u32>,
723    /// The counters of upstream DNS feature.
724    ///
725    /// Optional.
726    pub upstream_dns_counters: Option<UpstreamDnsCounters>,
727    #[doc(hidden)]
728    pub __source_breaking: fidl::marker::SourceBreaking,
729}
730
731impl fidl::Persistable for DnssdCounters {}
732
733/// LoWPAN External Route.
734///
735/// Informed by the Thread 1.1.1 Specification, section 5.13.3.
736#[derive(Clone, Debug, Default, PartialEq)]
737pub struct ExternalRoute {
738    /// Subnet for route. Required.
739    pub subnet: Option<fidl_fuchsia_net__common::Ipv6AddressWithPrefix>,
740    /// Indicates the what preference this route should be given relative
741    /// to other devices offering the same external route. If not present,
742    /// `MEDIUM` preference is assumed.
743    ///
744    /// Based on `R_preference` from Section 5.13.3 of the Thread 1.1.1
745    /// Specification.
746    pub route_preference: Option<RoutePreference>,
747    /// True if the route is expected to be available for at least Thread's
748    /// `MIN_STABLE_LIFETIME`; otherwise, `false`. If not present, assumed to
749    /// be `false`.
750    ///
751    /// The Thread specification defines `MIN_STABLE_LIFETIME` as 168 hours.
752    ///
753    /// Based on `R_stable` from Section 5.13.3 of the Thread 1.1.1
754    /// Specification.
755    pub stable: Option<bool>,
756    #[doc(hidden)]
757    pub __source_breaking: fidl::marker::SourceBreaking,
758}
759
760impl fidl::Persistable for ExternalRoute {}
761
762/// Parameters for joiner commissioning.
763///
764/// More information:
765/// https://www.threadgroup.org/Portals/0/documents/support/CommissioningWhitePaper_658_2.pdf
766#[derive(Clone, Debug, Default, PartialEq)]
767pub struct JoinerCommissioningParams {
768    /// Commissioning PSKd. Required.
769    pub pskd: Option<String>,
770    /// Provisioning URL. Optional.
771    pub provisioning_url: Option<String>,
772    /// Vendor name. Optional.
773    pub vendor_name: Option<String>,
774    /// Vendor model. Optional.
775    pub vendor_model: Option<String>,
776    /// Vendor Software Version. Optional.
777    pub vendor_sw_version: Option<String>,
778    /// Vendor data string. Optional.
779    pub vendor_data_string: Option<String>,
780    #[doc(hidden)]
781    pub __source_breaking: fidl::marker::SourceBreaking,
782}
783
784impl fidl::Persistable for JoinerCommissioningParams {}
785
786/// Node information for Thread network leaders.
787#[derive(Clone, Debug, Default, PartialEq)]
788pub struct LeaderData {
789    /// The network partition ID of the leader.
790    ///
791    /// Required.
792    pub partition_id: Option<u32>,
793    /// The weight of this leader on the network.
794    ///
795    /// Required.
796    pub weight: Option<u8>,
797    /// The full network data version.
798    ///
799    /// Required.
800    pub network_data_version: Option<u8>,
801    /// The stable network data version.
802    ///
803    /// Required.
804    pub stable_network_data_version: Option<u8>,
805    /// The router ID of the leader.
806    ///
807    /// Required.
808    pub router_id: Option<u8>,
809    #[doc(hidden)]
810    pub __source_breaking: fidl::marker::SourceBreaking,
811}
812
813impl fidl::Persistable for LeaderData {}
814
815/// Link Metrics info of the neighbors.
816#[derive(Clone, Debug, Default, PartialEq)]
817pub struct LinkMetricsEntry {
818    /// Link Margin value of the neighbor
819    pub link_margin: Option<u8>,
820    /// RSSI value of the neighbor
821    pub rssi: Option<i8>,
822    #[doc(hidden)]
823    pub __source_breaking: fidl::marker::SourceBreaking,
824}
825
826impl fidl::Persistable for LinkMetricsEntry {}
827
828#[derive(Clone, Debug, Default, PartialEq)]
829pub struct Nat64ErrorCounters {
830    /// Packet drop for unknown reasons
831    pub unknown: Option<Nat64PacketCounters>,
832    /// Packet drop due to failed to parse the datagram
833    pub illegal_packet: Option<Nat64PacketCounters>,
834    /// Packet drop due to unsupported IP protocol
835    pub unsupported_protocol: Option<Nat64PacketCounters>,
836    /// Packet drop due to no mappings found or mapping pool exhausted
837    pub no_mapping: Option<Nat64PacketCounters>,
838    #[doc(hidden)]
839    pub __source_breaking: fidl::marker::SourceBreaking,
840}
841
842impl fidl::Persistable for Nat64ErrorCounters {}
843
844#[derive(Clone, Debug, Default, PartialEq)]
845pub struct Nat64Info {
846    /// NAT64 border routing state
847    pub nat64_state: Option<BorderRoutingNat64State>,
848    /// NAT64 mapping
849    pub nat64_mappings: Option<Vec<Nat64Mapping>>,
850    /// NAT64 error counters
851    pub nat64_error_counters: Option<Nat64ErrorCounters>,
852    /// NAT64 protocol counters
853    pub nat64_protocol_counters: Option<Nat64ProtocolCounters>,
854    #[doc(hidden)]
855    pub __source_breaking: fidl::marker::SourceBreaking,
856}
857
858impl fidl::Persistable for Nat64Info {}
859
860/// Information about the mappings of NAT64 translator
861#[derive(Clone, Debug, Default, PartialEq)]
862pub struct Nat64Mapping {
863    /// The unique id for a mapping session
864    pub mapping_id: Option<u64>,
865    /// The IPv4 address of the mapping
866    pub ip4_addr: Option<Vec<u8>>,
867    /// The IPv6 address of the mapping
868    pub ip6_addr: Option<Vec<u8>>,
869    /// Remaining time before expiry in milliseconds
870    pub remaining_time_ms: Option<u32>,
871    /// Nat64 Counters
872    pub counters: Option<Nat64ProtocolCounters>,
873    #[doc(hidden)]
874    pub __source_breaking: fidl::marker::SourceBreaking,
875}
876
877impl fidl::Persistable for Nat64Mapping {}
878
879#[derive(Clone, Debug, Default, PartialEq)]
880pub struct Nat64PacketCounters {
881    /// Number of packets translated from IPv4 to IPv6
882    pub ipv4_to_ipv6_packets: Option<u64>,
883    /// Number of packets translated from IPv6 to IPv4
884    pub ipv6_to_ipv4_packets: Option<u64>,
885    #[doc(hidden)]
886    pub __source_breaking: fidl::marker::SourceBreaking,
887}
888
889impl fidl::Persistable for Nat64PacketCounters {}
890
891#[derive(Clone, Debug, Default, PartialEq)]
892pub struct Nat64ProtocolCounters {
893    /// TCP counters
894    pub tcp: Option<Nat64TrafficCounters>,
895    /// UDP counters
896    pub udp: Option<Nat64TrafficCounters>,
897    /// ICMP counters
898    pub icmp: Option<Nat64TrafficCounters>,
899    /// Total counters
900    pub total: Option<Nat64TrafficCounters>,
901    #[doc(hidden)]
902    pub __source_breaking: fidl::marker::SourceBreaking,
903}
904
905impl fidl::Persistable for Nat64ProtocolCounters {}
906
907#[derive(Clone, Debug, Default, PartialEq)]
908pub struct Nat64TrafficCounters {
909    /// Number of packets translated from IPv4 to IPv6
910    pub ipv4_to_ipv6_packets: Option<u64>,
911    /// Sum of size of packets translated from IPv4 to IPv6
912    pub ipv4_to_ipv6_bytes: Option<u64>,
913    /// Number of packets translated from IPv6 to IPv4
914    pub ipv6_to_ipv4_packets: Option<u64>,
915    /// Sum of size of packets translated from IPv6 to IPv4
916    pub ipv6_to_ipv4_bytes: Option<u64>,
917    #[doc(hidden)]
918    pub __source_breaking: fidl::marker::SourceBreaking,
919}
920
921impl fidl::Persistable for Nat64TrafficCounters {}
922
923/// Describes the parameters of a network scan.
924#[derive(Clone, Debug, Default, PartialEq)]
925pub struct NetworkScanParameters {
926    /// Subset of channels to scan.
927    ///
928    /// If unspecified, all channels will be scanned.
929    pub channels: Option<Vec<u16>>,
930    /// Transmit power (in dBm to the antenna) for transmitting
931    /// beacon requests.
932    ///
933    /// Note that hardware limitations may cause the actual
934    /// used transmit power to differ from what is specified.
935    /// In that case the used transmit power will always be
936    /// the highest available transmit power that is less than
937    /// the specified transmit power. If the desired transmit
938    /// power is lower than the lowest transmit power supported
939    /// by the hardware, then that will be used instead.
940    pub tx_power_dbm: Option<i8>,
941    #[doc(hidden)]
942    pub __source_breaking: fidl::marker::SourceBreaking,
943}
944
945impl fidl::Persistable for NetworkScanParameters {}
946
947/// LoWPAN On-Mesh Prefix.
948///
949/// Informed by the Thread 1.1.1 Specification, section 5.13.2.
950#[derive(Clone, Debug, Default, PartialEq)]
951pub struct OnMeshPrefix {
952    /// Subnet to advertise for devices to use on the network. Required.
953    pub subnet: Option<fidl_fuchsia_net__common::Ipv6AddressWithPrefix>,
954    /// If present, indicates that this device is offering a default route
955    /// as well as indicating the what preference this default
956    /// route should be given relative to other devices offering default
957    /// routes. If not present, no default route is advertised.
958    ///
959    /// Based on `P_default` and `P_preference` from Section 5.13.2 of the
960    /// Thread 1.1.1 Specification.
961    pub default_route_preference: Option<RoutePreference>,
962    /// True if the route is expected to be available for at least Thread's
963    /// `MIN_STABLE_LIFETIME`; otherwise `false`. If not present, assumed to
964    /// be `false`.
965    ///
966    /// The Thread specification defines `MIN_STABLE_LIFETIME` as 168 hours.
967    ///
968    /// Based on `P_stable` from Section 5.13.2 of the
969    /// Thread 1.1.1 Specification.
970    pub stable: Option<bool>,
971    /// True if network devices are allowed to use previously configured
972    /// addresses using this prefix. If not present, assumed to be `false`.
973    ///
974    /// "SLAAC" referrs to StateLess Address Auto Configuration, described in
975    /// [RFC4862](https://tools.ietf.org/html/rfc4862).
976    ///
977    /// Based on `P_slaac_preferred` from Section 5.13.2 of the
978    /// Thread 1.1.1 Specification.
979    pub slaac_preferred: Option<bool>,
980    /// True if network devices are allowed to autoconfigure addresses using
981    /// this prefix. If not present, assumed to be `false`.
982    ///
983    /// "SLAAC" referrs to StateLess Address Auto Configuration, described in
984    /// [RFC4862](https://tools.ietf.org/html/rfc4862).
985    ///
986    /// Based on `P_slaac_valid` from Section 5.13.2 of the
987    /// Thread 1.1.1 Specification.
988    pub slaac_valid: Option<bool>,
989    #[doc(hidden)]
990    pub __source_breaking: fidl::marker::SourceBreaking,
991}
992
993impl fidl::Persistable for OnMeshPrefix {}
994
995/// Platform counters related to processed RA info when DHCPv6 PD is enabled.
996#[derive(Clone, Debug, Default, PartialEq)]
997pub struct PdProcessedRaInfo {
998    /// The number of platform generated RA handled by ApplyPlatformGeneratedRa.
999    ///
1000    /// Required.
1001    pub num_platform_ra_received: Option<u32>,
1002    /// The number of PIO processed for adding OMR prefixes.
1003    ///
1004    /// Required.
1005    pub num_platform_pio_processed: Option<u32>,
1006    /// The duration since the last processed RA message.
1007    ///
1008    /// Required.
1009    pub last_platform_ra_msec: Option<u32>,
1010    #[doc(hidden)]
1011    pub __source_breaking: fidl::marker::SourceBreaking,
1012}
1013
1014impl fidl::Persistable for PdProcessedRaInfo {}
1015
1016/// State information about the SRP server.
1017#[derive(Clone, Debug, Default, PartialEq)]
1018pub struct SrpServerInfo {
1019    /// The operational state of the SRP server.
1020    ///
1021    /// Required.
1022    pub state: Option<SrpServerState>,
1023    /// The port the SRP server is listening to.
1024    ///
1025    /// Optional. The port may be omitted when `state` is `DISABLED`.
1026    pub port: Option<u16>,
1027    /// The address mode of the SRP server.
1028    ///
1029    /// Required.
1030    pub address_mode: Option<SrpServerAddressMode>,
1031    /// The response counters of the SRP server.
1032    ///
1033    /// Required.
1034    pub response_counters: Option<SrpServerResponseCounters>,
1035    /// The registration information of SRP hosts.
1036    ///
1037    /// Required.
1038    pub hosts_registration: Option<SrpServerRegistration>,
1039    /// The registration information of SRP services.
1040    ///
1041    /// Required.
1042    pub services_registration: Option<SrpServerRegistration>,
1043    #[doc(hidden)]
1044    pub __source_breaking: fidl::marker::SourceBreaking,
1045}
1046
1047impl fidl::Persistable for SrpServerInfo {}
1048
1049/// Registration information about the SRP server.
1050#[derive(Clone, Debug, Default, PartialEq)]
1051pub struct SrpServerRegistration {
1052    /// Number of hosts/services that have not been deleted.
1053    ///
1054    /// Required.
1055    pub fresh_count: Option<u32>,
1056    /// Number of hosts/services that have been deleted.
1057    ///
1058    /// Required.
1059    pub deleted_count: Option<u32>,
1060    /// Total lease time.
1061    ///
1062    /// Required.
1063    pub lease_time_total: Option<i64>,
1064    /// Total key lease time.
1065    ///
1066    /// Required.
1067    pub key_lease_time_total: Option<i64>,
1068    /// Total remaining lease time.
1069    ///
1070    /// Required.
1071    pub remaining_lease_time_total: Option<i64>,
1072    /// Total remaining key lease time.
1073    ///
1074    /// Required.
1075    pub remaining_key_lease_time_total: Option<i64>,
1076    #[doc(hidden)]
1077    pub __source_breaking: fidl::marker::SourceBreaking,
1078}
1079
1080impl fidl::Persistable for SrpServerRegistration {}
1081
1082#[derive(Clone, Debug, Default, PartialEq)]
1083pub struct SrpServerResponseCounters {
1084    /// The number of successful responses.
1085    ///
1086    /// Required.
1087    pub success_response: Option<u32>,
1088    /// The number of 'server failure' responses.
1089    ///
1090    /// Required.
1091    pub server_failure_response: Option<u32>,
1092    /// The number of 'format error' responses.
1093    ///
1094    /// Required.
1095    pub format_error_response: Option<u32>,
1096    /// The number of 'name exists' responses.
1097    ///
1098    /// Required.
1099    pub name_exists_response: Option<u32>,
1100    /// The number of 'refused' responses.
1101    ///
1102    /// Required.
1103    pub refused_response: Option<u32>,
1104    /// The number of 'other' responses.
1105    ///
1106    /// Required.
1107    pub other_response: Option<u32>,
1108    #[doc(hidden)]
1109    pub __source_breaking: fidl::marker::SourceBreaking,
1110}
1111
1112impl fidl::Persistable for SrpServerResponseCounters {}
1113
1114/// LoWPAN Interface Telemetry Information.
1115///
1116/// The fields in this table are used for providing low-level telemetry and information about the
1117/// LoWPAN interface for debugging and statistics purposes.
1118///
1119/// All fields are optional.
1120#[derive(Clone, Debug, Default, PartialEq)]
1121pub struct Telemetry {
1122    /// The current RSSI of the radio.
1123    pub rssi: Option<i8>,
1124    /// The configured transmit power of the radio.
1125    pub tx_power: Option<i8>,
1126    /// The current channel index of the radio.
1127    pub channel_index: Option<u16>,
1128    /// The partition ID of the currently associated network partition.
1129    pub partition_id: Option<u32>,
1130    /// The version string describing the underlying mesh stack.
1131    pub stack_version: Option<String>,
1132    /// The version string describing the underlying radio control firmware.
1133    pub rcp_version: Option<String>,
1134    /// Thread link mode byte.
1135    ///
1136    /// Only present on Thread networks.
1137    ///
1138    /// Defined by section 4.5.2 of the Thread 1.1.1 specification ("Mode TLV").
1139    pub thread_link_mode: Option<u8>,
1140    /// The router ID of this device in the currently associated network.
1141    ///
1142    /// Only present on Thread networks.
1143    pub thread_router_id: Option<u8>,
1144    /// The current RLOC16 address of this node.
1145    ///
1146    /// Only present on Thread networks.
1147    pub thread_rloc: Option<u16>,
1148    /// The full network data version.
1149    ///
1150    /// Only present on Thread networks.
1151    pub thread_network_data_version: Option<u8>,
1152    /// The stable network data version.
1153    ///
1154    /// Only present on Thread networks.
1155    pub thread_stable_network_data_version: Option<u8>,
1156    /// The current Thread network data, in raw binary form, as defined in section 5.13 of
1157    /// the Thread 1.1.1 specification.
1158    ///
1159    /// Only present on Thread networks.
1160    pub thread_network_data: Option<Vec<u8>>,
1161    /// The current Thread stable network data, in raw binary form, as defined in section 5.13 of
1162    /// the Thread 1.1.1 specification.
1163    ///
1164    /// Only present on Thread networks.
1165    pub thread_stable_network_data: Option<Vec<u8>>,
1166    /// The counters associated with border routing messages.
1167    ///
1168    /// Only present on Thread networks.
1169    pub thread_border_routing_counters: Option<BorderRoutingCounters>,
1170    /// The SRP server information.
1171    ///
1172    /// Only present on Thread networks.
1173    pub srp_server_info: Option<SrpServerInfo>,
1174    /// The DNS-SD server counters.
1175    ///
1176    /// Only present on Thread networks.
1177    pub dnssd_counters: Option<DnssdCounters>,
1178    /// The data associated with the leader of the currently associated Thread network.
1179    ///
1180    /// Only present on Thread networks.
1181    pub leader_data: Option<LeaderData>,
1182    /// The uptime of the current instance.
1183    ///
1184    /// Required.
1185    pub uptime: Option<i64>,
1186    /// Information about the NAT64
1187    ///
1188    /// Only present on Thread networks.
1189    pub nat64_info: Option<Nat64Info>,
1190    /// Information about the TREL interface, if available.
1191    ///
1192    /// Only present on Thread networks.
1193    pub trel_counters: Option<TrelCounters>,
1194    /// Information about the TREL peers, if available.
1195    ///
1196    /// Only present on Thread networks.
1197    pub trel_peers_info: Option<TrelPeersInfo>,
1198    /// Information about the Upstream DNS feature, if available.
1199    ///
1200    /// Only present on Thread networks.
1201    pub upstream_dns_info: Option<UpstreamDnsInfo>,
1202    /// Information about the DHCPv6 PD feature, if available.
1203    ///
1204    /// Only present on Thread networks.
1205    pub dhcp6pd_info: Option<Dhcp6PdInfo>,
1206    /// Link Metrics Manager related info, if available.
1207    ///
1208    /// Only present on Thread networks.
1209    pub link_metrics_entries: Option<Vec<LinkMetricsEntry>>,
1210    #[doc(hidden)]
1211    pub __source_breaking: fidl::marker::SourceBreaking,
1212}
1213
1214impl fidl::Persistable for Telemetry {}
1215
1216/// Represents a group of TREL related counters in the platform layer.
1217///
1218/// Derived from [`otPlatTrelCounters`](https://openthread.io/reference/struct/ot-plat-trel-counters).
1219#[derive(Clone, Debug, Default, PartialEq)]
1220pub struct TrelCounters {
1221    /// Sum of size of packets received through TREL.
1222    pub rx_bytes: Option<u64>,
1223    /// Number of packets received through TREL.
1224    pub rx_packets: Option<u64>,
1225    /// Sum of size of packets successfully transmitted through TREL.
1226    pub tx_bytes: Option<u64>,
1227    /// Number of packet transmission failures through TREL.
1228    pub tx_failure: Option<u64>,
1229    /// Number of packets successfully transmitted through TREL.
1230    pub tx_packets: Option<u64>,
1231    #[doc(hidden)]
1232    pub __source_breaking: fidl::marker::SourceBreaking,
1233}
1234
1235impl fidl::Persistable for TrelCounters {}
1236
1237/// Represents the TREL peer related info.
1238///
1239/// The info is available in OpenThread via https://openthread.io/reference/group/api-trel
1240/// More fields may be added per request.
1241#[derive(Clone, Debug, Default, PartialEq)]
1242pub struct TrelPeersInfo {
1243    /// Number of TREL peers for this Thread Border Router.
1244    ///
1245    /// Required.
1246    pub num_trel_peers: Option<u16>,
1247    #[doc(hidden)]
1248    pub __source_breaking: fidl::marker::SourceBreaking,
1249}
1250
1251impl fidl::Persistable for TrelPeersInfo {}
1252
1253/// Represents the count of queries, responses, failures handled by upstream DNS server
1254///
1255/// Derived from `otUpstreamDnsCounters`(https://openthread.io/reference/group/api-dnssd-server)
1256#[derive(Clone, Debug, Default, PartialEq)]
1257pub struct UpstreamDnsCounters {
1258    /// The number of queries forwarded
1259    ///
1260    /// Required.
1261    pub queries: Option<u32>,
1262    /// The number of responses forwarded
1263    ///
1264    /// Required.
1265    pub responses: Option<u32>,
1266    /// The number of upstream DNS failures
1267    ///
1268    /// Required.
1269    pub failures: Option<u32>,
1270    #[doc(hidden)]
1271    pub __source_breaking: fidl::marker::SourceBreaking,
1272}
1273
1274impl fidl::Persistable for UpstreamDnsCounters {}
1275
1276/// Represents the Upstream DNS related info.
1277///
1278/// The info is available in OpenThread via https://openthread.io/reference/group/api-dnssd-server
1279/// More fields may be added per request.
1280#[derive(Clone, Debug, Default, PartialEq)]
1281pub struct UpstreamDnsInfo {
1282    /// State of upstream DNS query.
1283    ///
1284    /// Required.
1285    pub upstream_dns_query_state: Option<UpstreamDnsQueryState>,
1286    #[doc(hidden)]
1287    pub __source_breaking: fidl::marker::SourceBreaking,
1288}
1289
1290impl fidl::Persistable for UpstreamDnsInfo {}
1291
1292/// Parameters for DeviceExtra::JoinNetwork command.
1293#[derive(Clone, Debug)]
1294pub enum JoinParams {
1295    /// Attempts to find and join a known pre-existing network.
1296    ProvisioningParameter(fidl_fuchsia_lowpan_device__common::ProvisioningParams),
1297    /// Attempts to find and join an unknown pre-existing network
1298    /// that is configured to accept and provision devices with
1299    /// the given shared secret, or PSKd. This allows new devices to
1300    /// join existing networks without knowing the credentials for
1301    /// the specific network.
1302    JoinerParameter(JoinerCommissioningParams),
1303    #[doc(hidden)]
1304    __SourceBreaking { unknown_ordinal: u64 },
1305}
1306
1307/// Pattern that matches an unknown `JoinParams` member.
1308#[macro_export]
1309macro_rules! JoinParamsUnknown {
1310    () => {
1311        _
1312    };
1313}
1314
1315// Custom PartialEq so that unknown variants are not equal to themselves.
1316impl PartialEq for JoinParams {
1317    fn eq(&self, other: &Self) -> bool {
1318        match (self, other) {
1319            (Self::ProvisioningParameter(x), Self::ProvisioningParameter(y)) => *x == *y,
1320            (Self::JoinerParameter(x), Self::JoinerParameter(y)) => *x == *y,
1321            _ => false,
1322        }
1323    }
1324}
1325
1326impl JoinParams {
1327    #[inline]
1328    pub fn ordinal(&self) -> u64 {
1329        match *self {
1330            Self::ProvisioningParameter(_) => 1,
1331            Self::JoinerParameter(_) => 2,
1332            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1333        }
1334    }
1335
1336    #[inline]
1337    pub fn unknown_variant_for_testing() -> Self {
1338        Self::__SourceBreaking { unknown_ordinal: 0 }
1339    }
1340
1341    #[inline]
1342    pub fn is_unknown(&self) -> bool {
1343        match self {
1344            Self::__SourceBreaking { .. } => true,
1345            _ => false,
1346        }
1347    }
1348}
1349
1350impl fidl::Persistable for JoinParams {}
1351
1352/// Indicates the current status of the form/join operation.
1353///
1354/// Returned by [`ProvisioningMonitor.WatchProgress`].
1355#[derive(Clone, Debug)]
1356pub enum ProvisioningProgress {
1357    /// Approximate percent complete indication for a user interface.
1358    Progress(f32),
1359    /// The final Identity when the operation has completed successfully.
1360    Identity(fidl_fuchsia_lowpan_device__common::Identity),
1361    #[doc(hidden)]
1362    __SourceBreaking { unknown_ordinal: u64 },
1363}
1364
1365/// Pattern that matches an unknown `ProvisioningProgress` member.
1366#[macro_export]
1367macro_rules! ProvisioningProgressUnknown {
1368    () => {
1369        _
1370    };
1371}
1372
1373// Custom PartialEq so that unknown variants are not equal to themselves.
1374impl PartialEq for ProvisioningProgress {
1375    fn eq(&self, other: &Self) -> bool {
1376        match (self, other) {
1377            (Self::Progress(x), Self::Progress(y)) => *x == *y,
1378            (Self::Identity(x), Self::Identity(y)) => *x == *y,
1379            _ => false,
1380        }
1381    }
1382}
1383
1384impl ProvisioningProgress {
1385    #[inline]
1386    pub fn ordinal(&self) -> u64 {
1387        match *self {
1388            Self::Progress(_) => 1,
1389            Self::Identity(_) => 2,
1390            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1391        }
1392    }
1393
1394    #[inline]
1395    pub fn unknown_variant_for_testing() -> Self {
1396        Self::__SourceBreaking { unknown_ordinal: 0 }
1397    }
1398
1399    #[inline]
1400    pub fn is_unknown(&self) -> bool {
1401        match self {
1402            Self::__SourceBreaking { .. } => true,
1403            _ => false,
1404        }
1405    }
1406}
1407
1408impl fidl::Persistable for ProvisioningProgress {}
1409
1410mod internal {
1411    use super::*;
1412    unsafe impl fidl::encoding::TypeMarker for Dhcp6PdState {
1413        type Owned = Self;
1414
1415        #[inline(always)]
1416        fn inline_align(_context: fidl::encoding::Context) -> usize {
1417            std::mem::align_of::<u32>()
1418        }
1419
1420        #[inline(always)]
1421        fn inline_size(_context: fidl::encoding::Context) -> usize {
1422            std::mem::size_of::<u32>()
1423        }
1424
1425        #[inline(always)]
1426        fn encode_is_copy() -> bool {
1427            false
1428        }
1429
1430        #[inline(always)]
1431        fn decode_is_copy() -> bool {
1432            false
1433        }
1434    }
1435
1436    impl fidl::encoding::ValueTypeMarker for Dhcp6PdState {
1437        type Borrowed<'a> = Self;
1438        #[inline(always)]
1439        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1440            *value
1441        }
1442    }
1443
1444    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Dhcp6PdState {
1445        #[inline]
1446        unsafe fn encode(
1447            self,
1448            encoder: &mut fidl::encoding::Encoder<'_, D>,
1449            offset: usize,
1450            _depth: fidl::encoding::Depth,
1451        ) -> fidl::Result<()> {
1452            encoder.debug_check_bounds::<Self>(offset);
1453            encoder.write_num(self.into_primitive(), offset);
1454            Ok(())
1455        }
1456    }
1457
1458    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Dhcp6PdState {
1459        #[inline(always)]
1460        fn new_empty() -> Self {
1461            Self::unknown()
1462        }
1463
1464        #[inline]
1465        unsafe fn decode(
1466            &mut self,
1467            decoder: &mut fidl::encoding::Decoder<'_, D>,
1468            offset: usize,
1469            _depth: fidl::encoding::Depth,
1470        ) -> fidl::Result<()> {
1471            decoder.debug_check_bounds::<Self>(offset);
1472            let prim = decoder.read_num::<u32>(offset);
1473
1474            *self = Self::from_primitive_allow_unknown(prim);
1475            Ok(())
1476        }
1477    }
1478    unsafe impl fidl::encoding::TypeMarker for Nat64State {
1479        type Owned = Self;
1480
1481        #[inline(always)]
1482        fn inline_align(_context: fidl::encoding::Context) -> usize {
1483            std::mem::align_of::<u32>()
1484        }
1485
1486        #[inline(always)]
1487        fn inline_size(_context: fidl::encoding::Context) -> usize {
1488            std::mem::size_of::<u32>()
1489        }
1490
1491        #[inline(always)]
1492        fn encode_is_copy() -> bool {
1493            false
1494        }
1495
1496        #[inline(always)]
1497        fn decode_is_copy() -> bool {
1498            false
1499        }
1500    }
1501
1502    impl fidl::encoding::ValueTypeMarker for Nat64State {
1503        type Borrowed<'a> = Self;
1504        #[inline(always)]
1505        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1506            *value
1507        }
1508    }
1509
1510    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Nat64State {
1511        #[inline]
1512        unsafe fn encode(
1513            self,
1514            encoder: &mut fidl::encoding::Encoder<'_, D>,
1515            offset: usize,
1516            _depth: fidl::encoding::Depth,
1517        ) -> fidl::Result<()> {
1518            encoder.debug_check_bounds::<Self>(offset);
1519            encoder.write_num(self.into_primitive(), offset);
1520            Ok(())
1521        }
1522    }
1523
1524    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64State {
1525        #[inline(always)]
1526        fn new_empty() -> Self {
1527            Self::unknown()
1528        }
1529
1530        #[inline]
1531        unsafe fn decode(
1532            &mut self,
1533            decoder: &mut fidl::encoding::Decoder<'_, D>,
1534            offset: usize,
1535            _depth: fidl::encoding::Depth,
1536        ) -> fidl::Result<()> {
1537            decoder.debug_check_bounds::<Self>(offset);
1538            let prim = decoder.read_num::<u32>(offset);
1539
1540            *self = Self::from_primitive_allow_unknown(prim);
1541            Ok(())
1542        }
1543    }
1544    unsafe impl fidl::encoding::TypeMarker for ProvisionError {
1545        type Owned = Self;
1546
1547        #[inline(always)]
1548        fn inline_align(_context: fidl::encoding::Context) -> usize {
1549            std::mem::align_of::<i32>()
1550        }
1551
1552        #[inline(always)]
1553        fn inline_size(_context: fidl::encoding::Context) -> usize {
1554            std::mem::size_of::<i32>()
1555        }
1556
1557        #[inline(always)]
1558        fn encode_is_copy() -> bool {
1559            false
1560        }
1561
1562        #[inline(always)]
1563        fn decode_is_copy() -> bool {
1564            false
1565        }
1566    }
1567
1568    impl fidl::encoding::ValueTypeMarker for ProvisionError {
1569        type Borrowed<'a> = Self;
1570        #[inline(always)]
1571        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1572            *value
1573        }
1574    }
1575
1576    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ProvisionError {
1577        #[inline]
1578        unsafe fn encode(
1579            self,
1580            encoder: &mut fidl::encoding::Encoder<'_, D>,
1581            offset: usize,
1582            _depth: fidl::encoding::Depth,
1583        ) -> fidl::Result<()> {
1584            encoder.debug_check_bounds::<Self>(offset);
1585            encoder.write_num(self.into_primitive(), offset);
1586            Ok(())
1587        }
1588    }
1589
1590    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProvisionError {
1591        #[inline(always)]
1592        fn new_empty() -> Self {
1593            Self::unknown()
1594        }
1595
1596        #[inline]
1597        unsafe fn decode(
1598            &mut self,
1599            decoder: &mut fidl::encoding::Decoder<'_, D>,
1600            offset: usize,
1601            _depth: fidl::encoding::Depth,
1602        ) -> fidl::Result<()> {
1603            decoder.debug_check_bounds::<Self>(offset);
1604            let prim = decoder.read_num::<i32>(offset);
1605
1606            *self = Self::from_primitive_allow_unknown(prim);
1607            Ok(())
1608        }
1609    }
1610    unsafe impl fidl::encoding::TypeMarker for RoutePreference {
1611        type Owned = Self;
1612
1613        #[inline(always)]
1614        fn inline_align(_context: fidl::encoding::Context) -> usize {
1615            std::mem::align_of::<i8>()
1616        }
1617
1618        #[inline(always)]
1619        fn inline_size(_context: fidl::encoding::Context) -> usize {
1620            std::mem::size_of::<i8>()
1621        }
1622
1623        #[inline(always)]
1624        fn encode_is_copy() -> bool {
1625            true
1626        }
1627
1628        #[inline(always)]
1629        fn decode_is_copy() -> bool {
1630            false
1631        }
1632    }
1633
1634    impl fidl::encoding::ValueTypeMarker for RoutePreference {
1635        type Borrowed<'a> = Self;
1636        #[inline(always)]
1637        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1638            *value
1639        }
1640    }
1641
1642    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1643        for RoutePreference
1644    {
1645        #[inline]
1646        unsafe fn encode(
1647            self,
1648            encoder: &mut fidl::encoding::Encoder<'_, D>,
1649            offset: usize,
1650            _depth: fidl::encoding::Depth,
1651        ) -> fidl::Result<()> {
1652            encoder.debug_check_bounds::<Self>(offset);
1653            encoder.write_num(self.into_primitive(), offset);
1654            Ok(())
1655        }
1656    }
1657
1658    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RoutePreference {
1659        #[inline(always)]
1660        fn new_empty() -> Self {
1661            Self::Low
1662        }
1663
1664        #[inline]
1665        unsafe fn decode(
1666            &mut self,
1667            decoder: &mut fidl::encoding::Decoder<'_, D>,
1668            offset: usize,
1669            _depth: fidl::encoding::Depth,
1670        ) -> fidl::Result<()> {
1671            decoder.debug_check_bounds::<Self>(offset);
1672            let prim = decoder.read_num::<i8>(offset);
1673
1674            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1675            Ok(())
1676        }
1677    }
1678    unsafe impl fidl::encoding::TypeMarker for SrpServerAddressMode {
1679        type Owned = Self;
1680
1681        #[inline(always)]
1682        fn inline_align(_context: fidl::encoding::Context) -> usize {
1683            std::mem::align_of::<u32>()
1684        }
1685
1686        #[inline(always)]
1687        fn inline_size(_context: fidl::encoding::Context) -> usize {
1688            std::mem::size_of::<u32>()
1689        }
1690
1691        #[inline(always)]
1692        fn encode_is_copy() -> bool {
1693            true
1694        }
1695
1696        #[inline(always)]
1697        fn decode_is_copy() -> bool {
1698            false
1699        }
1700    }
1701
1702    impl fidl::encoding::ValueTypeMarker for SrpServerAddressMode {
1703        type Borrowed<'a> = Self;
1704        #[inline(always)]
1705        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1706            *value
1707        }
1708    }
1709
1710    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1711        for SrpServerAddressMode
1712    {
1713        #[inline]
1714        unsafe fn encode(
1715            self,
1716            encoder: &mut fidl::encoding::Encoder<'_, D>,
1717            offset: usize,
1718            _depth: fidl::encoding::Depth,
1719        ) -> fidl::Result<()> {
1720            encoder.debug_check_bounds::<Self>(offset);
1721            encoder.write_num(self.into_primitive(), offset);
1722            Ok(())
1723        }
1724    }
1725
1726    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SrpServerAddressMode {
1727        #[inline(always)]
1728        fn new_empty() -> Self {
1729            Self::Unicast
1730        }
1731
1732        #[inline]
1733        unsafe fn decode(
1734            &mut self,
1735            decoder: &mut fidl::encoding::Decoder<'_, D>,
1736            offset: usize,
1737            _depth: fidl::encoding::Depth,
1738        ) -> fidl::Result<()> {
1739            decoder.debug_check_bounds::<Self>(offset);
1740            let prim = decoder.read_num::<u32>(offset);
1741
1742            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1743            Ok(())
1744        }
1745    }
1746    unsafe impl fidl::encoding::TypeMarker for SrpServerState {
1747        type Owned = Self;
1748
1749        #[inline(always)]
1750        fn inline_align(_context: fidl::encoding::Context) -> usize {
1751            std::mem::align_of::<u32>()
1752        }
1753
1754        #[inline(always)]
1755        fn inline_size(_context: fidl::encoding::Context) -> usize {
1756            std::mem::size_of::<u32>()
1757        }
1758
1759        #[inline(always)]
1760        fn encode_is_copy() -> bool {
1761            true
1762        }
1763
1764        #[inline(always)]
1765        fn decode_is_copy() -> bool {
1766            false
1767        }
1768    }
1769
1770    impl fidl::encoding::ValueTypeMarker for SrpServerState {
1771        type Borrowed<'a> = Self;
1772        #[inline(always)]
1773        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1774            *value
1775        }
1776    }
1777
1778    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SrpServerState {
1779        #[inline]
1780        unsafe fn encode(
1781            self,
1782            encoder: &mut fidl::encoding::Encoder<'_, D>,
1783            offset: usize,
1784            _depth: fidl::encoding::Depth,
1785        ) -> fidl::Result<()> {
1786            encoder.debug_check_bounds::<Self>(offset);
1787            encoder.write_num(self.into_primitive(), offset);
1788            Ok(())
1789        }
1790    }
1791
1792    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SrpServerState {
1793        #[inline(always)]
1794        fn new_empty() -> Self {
1795            Self::Disabled
1796        }
1797
1798        #[inline]
1799        unsafe fn decode(
1800            &mut self,
1801            decoder: &mut fidl::encoding::Decoder<'_, D>,
1802            offset: usize,
1803            _depth: fidl::encoding::Depth,
1804        ) -> fidl::Result<()> {
1805            decoder.debug_check_bounds::<Self>(offset);
1806            let prim = decoder.read_num::<u32>(offset);
1807
1808            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1809            Ok(())
1810        }
1811    }
1812    unsafe impl fidl::encoding::TypeMarker for UpstreamDnsQueryState {
1813        type Owned = Self;
1814
1815        #[inline(always)]
1816        fn inline_align(_context: fidl::encoding::Context) -> usize {
1817            std::mem::align_of::<u32>()
1818        }
1819
1820        #[inline(always)]
1821        fn inline_size(_context: fidl::encoding::Context) -> usize {
1822            std::mem::size_of::<u32>()
1823        }
1824
1825        #[inline(always)]
1826        fn encode_is_copy() -> bool {
1827            false
1828        }
1829
1830        #[inline(always)]
1831        fn decode_is_copy() -> bool {
1832            false
1833        }
1834    }
1835
1836    impl fidl::encoding::ValueTypeMarker for UpstreamDnsQueryState {
1837        type Borrowed<'a> = Self;
1838        #[inline(always)]
1839        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1840            *value
1841        }
1842    }
1843
1844    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1845        for UpstreamDnsQueryState
1846    {
1847        #[inline]
1848        unsafe fn encode(
1849            self,
1850            encoder: &mut fidl::encoding::Encoder<'_, D>,
1851            offset: usize,
1852            _depth: fidl::encoding::Depth,
1853        ) -> fidl::Result<()> {
1854            encoder.debug_check_bounds::<Self>(offset);
1855            encoder.write_num(self.into_primitive(), offset);
1856            Ok(())
1857        }
1858    }
1859
1860    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UpstreamDnsQueryState {
1861        #[inline(always)]
1862        fn new_empty() -> Self {
1863            Self::unknown()
1864        }
1865
1866        #[inline]
1867        unsafe fn decode(
1868            &mut self,
1869            decoder: &mut fidl::encoding::Decoder<'_, D>,
1870            offset: usize,
1871            _depth: fidl::encoding::Depth,
1872        ) -> fidl::Result<()> {
1873            decoder.debug_check_bounds::<Self>(offset);
1874            let prim = decoder.read_num::<u32>(offset);
1875
1876            *self = Self::from_primitive_allow_unknown(prim);
1877            Ok(())
1878        }
1879    }
1880
1881    impl fidl::encoding::ValueTypeMarker for BeaconInfoStreamNextResponse {
1882        type Borrowed<'a> = &'a Self;
1883        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1884            value
1885        }
1886    }
1887
1888    unsafe impl fidl::encoding::TypeMarker for BeaconInfoStreamNextResponse {
1889        type Owned = Self;
1890
1891        #[inline(always)]
1892        fn inline_align(_context: fidl::encoding::Context) -> usize {
1893            8
1894        }
1895
1896        #[inline(always)]
1897        fn inline_size(_context: fidl::encoding::Context) -> usize {
1898            16
1899        }
1900    }
1901
1902    unsafe impl<D: fidl::encoding::ResourceDialect>
1903        fidl::encoding::Encode<BeaconInfoStreamNextResponse, D> for &BeaconInfoStreamNextResponse
1904    {
1905        #[inline]
1906        unsafe fn encode(
1907            self,
1908            encoder: &mut fidl::encoding::Encoder<'_, D>,
1909            offset: usize,
1910            _depth: fidl::encoding::Depth,
1911        ) -> fidl::Result<()> {
1912            encoder.debug_check_bounds::<BeaconInfoStreamNextResponse>(offset);
1913            // Delegate to tuple encoding.
1914            fidl::encoding::Encode::<BeaconInfoStreamNextResponse, D>::encode(
1915                (
1916                    <fidl::encoding::Vector<BeaconInfo, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.beacons),
1917                ),
1918                encoder, offset, _depth
1919            )
1920        }
1921    }
1922    unsafe impl<
1923            D: fidl::encoding::ResourceDialect,
1924            T0: fidl::encoding::Encode<fidl::encoding::Vector<BeaconInfo, 32>, D>,
1925        > fidl::encoding::Encode<BeaconInfoStreamNextResponse, D> for (T0,)
1926    {
1927        #[inline]
1928        unsafe fn encode(
1929            self,
1930            encoder: &mut fidl::encoding::Encoder<'_, D>,
1931            offset: usize,
1932            depth: fidl::encoding::Depth,
1933        ) -> fidl::Result<()> {
1934            encoder.debug_check_bounds::<BeaconInfoStreamNextResponse>(offset);
1935            // Zero out padding regions. There's no need to apply masks
1936            // because the unmasked parts will be overwritten by fields.
1937            // Write the fields.
1938            self.0.encode(encoder, offset + 0, depth)?;
1939            Ok(())
1940        }
1941    }
1942
1943    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1944        for BeaconInfoStreamNextResponse
1945    {
1946        #[inline(always)]
1947        fn new_empty() -> Self {
1948            Self { beacons: fidl::new_empty!(fidl::encoding::Vector<BeaconInfo, 32>, D) }
1949        }
1950
1951        #[inline]
1952        unsafe fn decode(
1953            &mut self,
1954            decoder: &mut fidl::encoding::Decoder<'_, D>,
1955            offset: usize,
1956            _depth: fidl::encoding::Depth,
1957        ) -> fidl::Result<()> {
1958            decoder.debug_check_bounds::<Self>(offset);
1959            // Verify that padding bytes are zero.
1960            fidl::decode!(fidl::encoding::Vector<BeaconInfo, 32>, D, &mut self.beacons, decoder, offset + 0, _depth)?;
1961            Ok(())
1962        }
1963    }
1964
1965    impl fidl::encoding::ValueTypeMarker for DeviceGetSupportedChannelsResponse {
1966        type Borrowed<'a> = &'a Self;
1967        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1968            value
1969        }
1970    }
1971
1972    unsafe impl fidl::encoding::TypeMarker for DeviceGetSupportedChannelsResponse {
1973        type Owned = Self;
1974
1975        #[inline(always)]
1976        fn inline_align(_context: fidl::encoding::Context) -> usize {
1977            8
1978        }
1979
1980        #[inline(always)]
1981        fn inline_size(_context: fidl::encoding::Context) -> usize {
1982            16
1983        }
1984    }
1985
1986    unsafe impl<D: fidl::encoding::ResourceDialect>
1987        fidl::encoding::Encode<DeviceGetSupportedChannelsResponse, D>
1988        for &DeviceGetSupportedChannelsResponse
1989    {
1990        #[inline]
1991        unsafe fn encode(
1992            self,
1993            encoder: &mut fidl::encoding::Encoder<'_, D>,
1994            offset: usize,
1995            _depth: fidl::encoding::Depth,
1996        ) -> fidl::Result<()> {
1997            encoder.debug_check_bounds::<DeviceGetSupportedChannelsResponse>(offset);
1998            // Delegate to tuple encoding.
1999            fidl::encoding::Encode::<DeviceGetSupportedChannelsResponse, D>::encode(
2000                (
2001                    <fidl::encoding::Vector<ChannelInfo, 200> as fidl::encoding::ValueTypeMarker>::borrow(&self.channels_info),
2002                ),
2003                encoder, offset, _depth
2004            )
2005        }
2006    }
2007    unsafe impl<
2008            D: fidl::encoding::ResourceDialect,
2009            T0: fidl::encoding::Encode<fidl::encoding::Vector<ChannelInfo, 200>, D>,
2010        > fidl::encoding::Encode<DeviceGetSupportedChannelsResponse, D> for (T0,)
2011    {
2012        #[inline]
2013        unsafe fn encode(
2014            self,
2015            encoder: &mut fidl::encoding::Encoder<'_, D>,
2016            offset: usize,
2017            depth: fidl::encoding::Depth,
2018        ) -> fidl::Result<()> {
2019            encoder.debug_check_bounds::<DeviceGetSupportedChannelsResponse>(offset);
2020            // Zero out padding regions. There's no need to apply masks
2021            // because the unmasked parts will be overwritten by fields.
2022            // Write the fields.
2023            self.0.encode(encoder, offset + 0, depth)?;
2024            Ok(())
2025        }
2026    }
2027
2028    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2029        for DeviceGetSupportedChannelsResponse
2030    {
2031        #[inline(always)]
2032        fn new_empty() -> Self {
2033            Self { channels_info: fidl::new_empty!(fidl::encoding::Vector<ChannelInfo, 200>, D) }
2034        }
2035
2036        #[inline]
2037        unsafe fn decode(
2038            &mut self,
2039            decoder: &mut fidl::encoding::Decoder<'_, D>,
2040            offset: usize,
2041            _depth: fidl::encoding::Depth,
2042        ) -> fidl::Result<()> {
2043            decoder.debug_check_bounds::<Self>(offset);
2044            // Verify that padding bytes are zero.
2045            fidl::decode!(fidl::encoding::Vector<ChannelInfo, 200>, D, &mut self.channels_info, decoder, offset + 0, _depth)?;
2046            Ok(())
2047        }
2048    }
2049
2050    impl fidl::encoding::ValueTypeMarker for DeviceRouteExtraGetLocalExternalRoutesResponse {
2051        type Borrowed<'a> = &'a Self;
2052        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2053            value
2054        }
2055    }
2056
2057    unsafe impl fidl::encoding::TypeMarker for DeviceRouteExtraGetLocalExternalRoutesResponse {
2058        type Owned = Self;
2059
2060        #[inline(always)]
2061        fn inline_align(_context: fidl::encoding::Context) -> usize {
2062            8
2063        }
2064
2065        #[inline(always)]
2066        fn inline_size(_context: fidl::encoding::Context) -> usize {
2067            16
2068        }
2069    }
2070
2071    unsafe impl<D: fidl::encoding::ResourceDialect>
2072        fidl::encoding::Encode<DeviceRouteExtraGetLocalExternalRoutesResponse, D>
2073        for &DeviceRouteExtraGetLocalExternalRoutesResponse
2074    {
2075        #[inline]
2076        unsafe fn encode(
2077            self,
2078            encoder: &mut fidl::encoding::Encoder<'_, D>,
2079            offset: usize,
2080            _depth: fidl::encoding::Depth,
2081        ) -> fidl::Result<()> {
2082            encoder.debug_check_bounds::<DeviceRouteExtraGetLocalExternalRoutesResponse>(offset);
2083            // Delegate to tuple encoding.
2084            fidl::encoding::Encode::<DeviceRouteExtraGetLocalExternalRoutesResponse, D>::encode(
2085                (
2086                    <fidl::encoding::Vector<ExternalRoute, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.external_routes),
2087                ),
2088                encoder, offset, _depth
2089            )
2090        }
2091    }
2092    unsafe impl<
2093            D: fidl::encoding::ResourceDialect,
2094            T0: fidl::encoding::Encode<fidl::encoding::Vector<ExternalRoute, 32>, D>,
2095        > fidl::encoding::Encode<DeviceRouteExtraGetLocalExternalRoutesResponse, D> for (T0,)
2096    {
2097        #[inline]
2098        unsafe fn encode(
2099            self,
2100            encoder: &mut fidl::encoding::Encoder<'_, D>,
2101            offset: usize,
2102            depth: fidl::encoding::Depth,
2103        ) -> fidl::Result<()> {
2104            encoder.debug_check_bounds::<DeviceRouteExtraGetLocalExternalRoutesResponse>(offset);
2105            // Zero out padding regions. There's no need to apply masks
2106            // because the unmasked parts will be overwritten by fields.
2107            // Write the fields.
2108            self.0.encode(encoder, offset + 0, depth)?;
2109            Ok(())
2110        }
2111    }
2112
2113    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2114        for DeviceRouteExtraGetLocalExternalRoutesResponse
2115    {
2116        #[inline(always)]
2117        fn new_empty() -> Self {
2118            Self { external_routes: fidl::new_empty!(fidl::encoding::Vector<ExternalRoute, 32>, D) }
2119        }
2120
2121        #[inline]
2122        unsafe fn decode(
2123            &mut self,
2124            decoder: &mut fidl::encoding::Decoder<'_, D>,
2125            offset: usize,
2126            _depth: fidl::encoding::Depth,
2127        ) -> fidl::Result<()> {
2128            decoder.debug_check_bounds::<Self>(offset);
2129            // Verify that padding bytes are zero.
2130            fidl::decode!(fidl::encoding::Vector<ExternalRoute, 32>, D, &mut self.external_routes, decoder, offset + 0, _depth)?;
2131            Ok(())
2132        }
2133    }
2134
2135    impl fidl::encoding::ValueTypeMarker for DeviceRouteExtraGetLocalOnMeshPrefixesResponse {
2136        type Borrowed<'a> = &'a Self;
2137        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2138            value
2139        }
2140    }
2141
2142    unsafe impl fidl::encoding::TypeMarker for DeviceRouteExtraGetLocalOnMeshPrefixesResponse {
2143        type Owned = Self;
2144
2145        #[inline(always)]
2146        fn inline_align(_context: fidl::encoding::Context) -> usize {
2147            8
2148        }
2149
2150        #[inline(always)]
2151        fn inline_size(_context: fidl::encoding::Context) -> usize {
2152            16
2153        }
2154    }
2155
2156    unsafe impl<D: fidl::encoding::ResourceDialect>
2157        fidl::encoding::Encode<DeviceRouteExtraGetLocalOnMeshPrefixesResponse, D>
2158        for &DeviceRouteExtraGetLocalOnMeshPrefixesResponse
2159    {
2160        #[inline]
2161        unsafe fn encode(
2162            self,
2163            encoder: &mut fidl::encoding::Encoder<'_, D>,
2164            offset: usize,
2165            _depth: fidl::encoding::Depth,
2166        ) -> fidl::Result<()> {
2167            encoder.debug_check_bounds::<DeviceRouteExtraGetLocalOnMeshPrefixesResponse>(offset);
2168            // Delegate to tuple encoding.
2169            fidl::encoding::Encode::<DeviceRouteExtraGetLocalOnMeshPrefixesResponse, D>::encode(
2170                (
2171                    <fidl::encoding::Vector<OnMeshPrefix, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.prefixes),
2172                ),
2173                encoder, offset, _depth
2174            )
2175        }
2176    }
2177    unsafe impl<
2178            D: fidl::encoding::ResourceDialect,
2179            T0: fidl::encoding::Encode<fidl::encoding::Vector<OnMeshPrefix, 32>, D>,
2180        > fidl::encoding::Encode<DeviceRouteExtraGetLocalOnMeshPrefixesResponse, D> for (T0,)
2181    {
2182        #[inline]
2183        unsafe fn encode(
2184            self,
2185            encoder: &mut fidl::encoding::Encoder<'_, D>,
2186            offset: usize,
2187            depth: fidl::encoding::Depth,
2188        ) -> fidl::Result<()> {
2189            encoder.debug_check_bounds::<DeviceRouteExtraGetLocalOnMeshPrefixesResponse>(offset);
2190            // Zero out padding regions. There's no need to apply masks
2191            // because the unmasked parts will be overwritten by fields.
2192            // Write the fields.
2193            self.0.encode(encoder, offset + 0, depth)?;
2194            Ok(())
2195        }
2196    }
2197
2198    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2199        for DeviceRouteExtraGetLocalOnMeshPrefixesResponse
2200    {
2201        #[inline(always)]
2202        fn new_empty() -> Self {
2203            Self { prefixes: fidl::new_empty!(fidl::encoding::Vector<OnMeshPrefix, 32>, D) }
2204        }
2205
2206        #[inline]
2207        unsafe fn decode(
2208            &mut self,
2209            decoder: &mut fidl::encoding::Decoder<'_, D>,
2210            offset: usize,
2211            _depth: fidl::encoding::Depth,
2212        ) -> fidl::Result<()> {
2213            decoder.debug_check_bounds::<Self>(offset);
2214            // Verify that padding bytes are zero.
2215            fidl::decode!(fidl::encoding::Vector<OnMeshPrefix, 32>, D, &mut self.prefixes, decoder, offset + 0, _depth)?;
2216            Ok(())
2217        }
2218    }
2219
2220    impl fidl::encoding::ValueTypeMarker for DeviceRouteRegisterExternalRouteRequest {
2221        type Borrowed<'a> = &'a Self;
2222        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2223            value
2224        }
2225    }
2226
2227    unsafe impl fidl::encoding::TypeMarker for DeviceRouteRegisterExternalRouteRequest {
2228        type Owned = Self;
2229
2230        #[inline(always)]
2231        fn inline_align(_context: fidl::encoding::Context) -> usize {
2232            8
2233        }
2234
2235        #[inline(always)]
2236        fn inline_size(_context: fidl::encoding::Context) -> usize {
2237            16
2238        }
2239    }
2240
2241    unsafe impl<D: fidl::encoding::ResourceDialect>
2242        fidl::encoding::Encode<DeviceRouteRegisterExternalRouteRequest, D>
2243        for &DeviceRouteRegisterExternalRouteRequest
2244    {
2245        #[inline]
2246        unsafe fn encode(
2247            self,
2248            encoder: &mut fidl::encoding::Encoder<'_, D>,
2249            offset: usize,
2250            _depth: fidl::encoding::Depth,
2251        ) -> fidl::Result<()> {
2252            encoder.debug_check_bounds::<DeviceRouteRegisterExternalRouteRequest>(offset);
2253            // Delegate to tuple encoding.
2254            fidl::encoding::Encode::<DeviceRouteRegisterExternalRouteRequest, D>::encode(
2255                (<ExternalRoute as fidl::encoding::ValueTypeMarker>::borrow(&self.external_route),),
2256                encoder,
2257                offset,
2258                _depth,
2259            )
2260        }
2261    }
2262    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ExternalRoute, D>>
2263        fidl::encoding::Encode<DeviceRouteRegisterExternalRouteRequest, D> for (T0,)
2264    {
2265        #[inline]
2266        unsafe fn encode(
2267            self,
2268            encoder: &mut fidl::encoding::Encoder<'_, D>,
2269            offset: usize,
2270            depth: fidl::encoding::Depth,
2271        ) -> fidl::Result<()> {
2272            encoder.debug_check_bounds::<DeviceRouteRegisterExternalRouteRequest>(offset);
2273            // Zero out padding regions. There's no need to apply masks
2274            // because the unmasked parts will be overwritten by fields.
2275            // Write the fields.
2276            self.0.encode(encoder, offset + 0, depth)?;
2277            Ok(())
2278        }
2279    }
2280
2281    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2282        for DeviceRouteRegisterExternalRouteRequest
2283    {
2284        #[inline(always)]
2285        fn new_empty() -> Self {
2286            Self { external_route: fidl::new_empty!(ExternalRoute, D) }
2287        }
2288
2289        #[inline]
2290        unsafe fn decode(
2291            &mut self,
2292            decoder: &mut fidl::encoding::Decoder<'_, D>,
2293            offset: usize,
2294            _depth: fidl::encoding::Depth,
2295        ) -> fidl::Result<()> {
2296            decoder.debug_check_bounds::<Self>(offset);
2297            // Verify that padding bytes are zero.
2298            fidl::decode!(ExternalRoute, D, &mut self.external_route, decoder, offset + 0, _depth)?;
2299            Ok(())
2300        }
2301    }
2302
2303    impl fidl::encoding::ValueTypeMarker for DeviceRouteRegisterOnMeshPrefixRequest {
2304        type Borrowed<'a> = &'a Self;
2305        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2306            value
2307        }
2308    }
2309
2310    unsafe impl fidl::encoding::TypeMarker for DeviceRouteRegisterOnMeshPrefixRequest {
2311        type Owned = Self;
2312
2313        #[inline(always)]
2314        fn inline_align(_context: fidl::encoding::Context) -> usize {
2315            8
2316        }
2317
2318        #[inline(always)]
2319        fn inline_size(_context: fidl::encoding::Context) -> usize {
2320            16
2321        }
2322    }
2323
2324    unsafe impl<D: fidl::encoding::ResourceDialect>
2325        fidl::encoding::Encode<DeviceRouteRegisterOnMeshPrefixRequest, D>
2326        for &DeviceRouteRegisterOnMeshPrefixRequest
2327    {
2328        #[inline]
2329        unsafe fn encode(
2330            self,
2331            encoder: &mut fidl::encoding::Encoder<'_, D>,
2332            offset: usize,
2333            _depth: fidl::encoding::Depth,
2334        ) -> fidl::Result<()> {
2335            encoder.debug_check_bounds::<DeviceRouteRegisterOnMeshPrefixRequest>(offset);
2336            // Delegate to tuple encoding.
2337            fidl::encoding::Encode::<DeviceRouteRegisterOnMeshPrefixRequest, D>::encode(
2338                (<OnMeshPrefix as fidl::encoding::ValueTypeMarker>::borrow(&self.prefix),),
2339                encoder,
2340                offset,
2341                _depth,
2342            )
2343        }
2344    }
2345    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<OnMeshPrefix, D>>
2346        fidl::encoding::Encode<DeviceRouteRegisterOnMeshPrefixRequest, D> for (T0,)
2347    {
2348        #[inline]
2349        unsafe fn encode(
2350            self,
2351            encoder: &mut fidl::encoding::Encoder<'_, D>,
2352            offset: usize,
2353            depth: fidl::encoding::Depth,
2354        ) -> fidl::Result<()> {
2355            encoder.debug_check_bounds::<DeviceRouteRegisterOnMeshPrefixRequest>(offset);
2356            // Zero out padding regions. There's no need to apply masks
2357            // because the unmasked parts will be overwritten by fields.
2358            // Write the fields.
2359            self.0.encode(encoder, offset + 0, depth)?;
2360            Ok(())
2361        }
2362    }
2363
2364    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2365        for DeviceRouteRegisterOnMeshPrefixRequest
2366    {
2367        #[inline(always)]
2368        fn new_empty() -> Self {
2369            Self { prefix: fidl::new_empty!(OnMeshPrefix, D) }
2370        }
2371
2372        #[inline]
2373        unsafe fn decode(
2374            &mut self,
2375            decoder: &mut fidl::encoding::Decoder<'_, D>,
2376            offset: usize,
2377            _depth: fidl::encoding::Depth,
2378        ) -> fidl::Result<()> {
2379            decoder.debug_check_bounds::<Self>(offset);
2380            // Verify that padding bytes are zero.
2381            fidl::decode!(OnMeshPrefix, D, &mut self.prefix, decoder, offset + 0, _depth)?;
2382            Ok(())
2383        }
2384    }
2385
2386    impl fidl::encoding::ValueTypeMarker for DeviceRouteUnregisterExternalRouteRequest {
2387        type Borrowed<'a> = &'a Self;
2388        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2389            value
2390        }
2391    }
2392
2393    unsafe impl fidl::encoding::TypeMarker for DeviceRouteUnregisterExternalRouteRequest {
2394        type Owned = Self;
2395
2396        #[inline(always)]
2397        fn inline_align(_context: fidl::encoding::Context) -> usize {
2398            1
2399        }
2400
2401        #[inline(always)]
2402        fn inline_size(_context: fidl::encoding::Context) -> usize {
2403            17
2404        }
2405    }
2406
2407    unsafe impl<D: fidl::encoding::ResourceDialect>
2408        fidl::encoding::Encode<DeviceRouteUnregisterExternalRouteRequest, D>
2409        for &DeviceRouteUnregisterExternalRouteRequest
2410    {
2411        #[inline]
2412        unsafe fn encode(
2413            self,
2414            encoder: &mut fidl::encoding::Encoder<'_, D>,
2415            offset: usize,
2416            _depth: fidl::encoding::Depth,
2417        ) -> fidl::Result<()> {
2418            encoder.debug_check_bounds::<DeviceRouteUnregisterExternalRouteRequest>(offset);
2419            // Delegate to tuple encoding.
2420            fidl::encoding::Encode::<DeviceRouteUnregisterExternalRouteRequest, D>::encode(
2421                (
2422                    <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow(&self.subnet),
2423                ),
2424                encoder, offset, _depth
2425            )
2426        }
2427    }
2428    unsafe impl<
2429            D: fidl::encoding::ResourceDialect,
2430            T0: fidl::encoding::Encode<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>,
2431        > fidl::encoding::Encode<DeviceRouteUnregisterExternalRouteRequest, D> for (T0,)
2432    {
2433        #[inline]
2434        unsafe fn encode(
2435            self,
2436            encoder: &mut fidl::encoding::Encoder<'_, D>,
2437            offset: usize,
2438            depth: fidl::encoding::Depth,
2439        ) -> fidl::Result<()> {
2440            encoder.debug_check_bounds::<DeviceRouteUnregisterExternalRouteRequest>(offset);
2441            // Zero out padding regions. There's no need to apply masks
2442            // because the unmasked parts will be overwritten by fields.
2443            // Write the fields.
2444            self.0.encode(encoder, offset + 0, depth)?;
2445            Ok(())
2446        }
2447    }
2448
2449    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2450        for DeviceRouteUnregisterExternalRouteRequest
2451    {
2452        #[inline(always)]
2453        fn new_empty() -> Self {
2454            Self { subnet: fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D) }
2455        }
2456
2457        #[inline]
2458        unsafe fn decode(
2459            &mut self,
2460            decoder: &mut fidl::encoding::Decoder<'_, D>,
2461            offset: usize,
2462            _depth: fidl::encoding::Depth,
2463        ) -> fidl::Result<()> {
2464            decoder.debug_check_bounds::<Self>(offset);
2465            // Verify that padding bytes are zero.
2466            fidl::decode!(
2467                fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
2468                D,
2469                &mut self.subnet,
2470                decoder,
2471                offset + 0,
2472                _depth
2473            )?;
2474            Ok(())
2475        }
2476    }
2477
2478    impl fidl::encoding::ValueTypeMarker for DeviceRouteUnregisterOnMeshPrefixRequest {
2479        type Borrowed<'a> = &'a Self;
2480        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2481            value
2482        }
2483    }
2484
2485    unsafe impl fidl::encoding::TypeMarker for DeviceRouteUnregisterOnMeshPrefixRequest {
2486        type Owned = Self;
2487
2488        #[inline(always)]
2489        fn inline_align(_context: fidl::encoding::Context) -> usize {
2490            1
2491        }
2492
2493        #[inline(always)]
2494        fn inline_size(_context: fidl::encoding::Context) -> usize {
2495            17
2496        }
2497    }
2498
2499    unsafe impl<D: fidl::encoding::ResourceDialect>
2500        fidl::encoding::Encode<DeviceRouteUnregisterOnMeshPrefixRequest, D>
2501        for &DeviceRouteUnregisterOnMeshPrefixRequest
2502    {
2503        #[inline]
2504        unsafe fn encode(
2505            self,
2506            encoder: &mut fidl::encoding::Encoder<'_, D>,
2507            offset: usize,
2508            _depth: fidl::encoding::Depth,
2509        ) -> fidl::Result<()> {
2510            encoder.debug_check_bounds::<DeviceRouteUnregisterOnMeshPrefixRequest>(offset);
2511            // Delegate to tuple encoding.
2512            fidl::encoding::Encode::<DeviceRouteUnregisterOnMeshPrefixRequest, D>::encode(
2513                (
2514                    <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow(&self.subnet),
2515                ),
2516                encoder, offset, _depth
2517            )
2518        }
2519    }
2520    unsafe impl<
2521            D: fidl::encoding::ResourceDialect,
2522            T0: fidl::encoding::Encode<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>,
2523        > fidl::encoding::Encode<DeviceRouteUnregisterOnMeshPrefixRequest, D> for (T0,)
2524    {
2525        #[inline]
2526        unsafe fn encode(
2527            self,
2528            encoder: &mut fidl::encoding::Encoder<'_, D>,
2529            offset: usize,
2530            depth: fidl::encoding::Depth,
2531        ) -> fidl::Result<()> {
2532            encoder.debug_check_bounds::<DeviceRouteUnregisterOnMeshPrefixRequest>(offset);
2533            // Zero out padding regions. There's no need to apply masks
2534            // because the unmasked parts will be overwritten by fields.
2535            // Write the fields.
2536            self.0.encode(encoder, offset + 0, depth)?;
2537            Ok(())
2538        }
2539    }
2540
2541    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2542        for DeviceRouteUnregisterOnMeshPrefixRequest
2543    {
2544        #[inline(always)]
2545        fn new_empty() -> Self {
2546            Self { subnet: fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D) }
2547        }
2548
2549        #[inline]
2550        unsafe fn decode(
2551            &mut self,
2552            decoder: &mut fidl::encoding::Decoder<'_, D>,
2553            offset: usize,
2554            _depth: fidl::encoding::Depth,
2555        ) -> fidl::Result<()> {
2556            decoder.debug_check_bounds::<Self>(offset);
2557            // Verify that padding bytes are zero.
2558            fidl::decode!(
2559                fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
2560                D,
2561                &mut self.subnet,
2562                decoder,
2563                offset + 0,
2564                _depth
2565            )?;
2566            Ok(())
2567        }
2568    }
2569
2570    impl fidl::encoding::ValueTypeMarker for LegacyJoiningMakeJoinableRequest {
2571        type Borrowed<'a> = &'a Self;
2572        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2573            value
2574        }
2575    }
2576
2577    unsafe impl fidl::encoding::TypeMarker for LegacyJoiningMakeJoinableRequest {
2578        type Owned = Self;
2579
2580        #[inline(always)]
2581        fn inline_align(_context: fidl::encoding::Context) -> usize {
2582            8
2583        }
2584
2585        #[inline(always)]
2586        fn inline_size(_context: fidl::encoding::Context) -> usize {
2587            16
2588        }
2589    }
2590
2591    unsafe impl<D: fidl::encoding::ResourceDialect>
2592        fidl::encoding::Encode<LegacyJoiningMakeJoinableRequest, D>
2593        for &LegacyJoiningMakeJoinableRequest
2594    {
2595        #[inline]
2596        unsafe fn encode(
2597            self,
2598            encoder: &mut fidl::encoding::Encoder<'_, D>,
2599            offset: usize,
2600            _depth: fidl::encoding::Depth,
2601        ) -> fidl::Result<()> {
2602            encoder.debug_check_bounds::<LegacyJoiningMakeJoinableRequest>(offset);
2603            unsafe {
2604                // Copy the object into the buffer.
2605                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2606                (buf_ptr as *mut LegacyJoiningMakeJoinableRequest)
2607                    .write_unaligned((self as *const LegacyJoiningMakeJoinableRequest).read());
2608                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2609                // done second because the memcpy will write garbage to these bytes.
2610                let padding_ptr = buf_ptr.offset(8) as *mut u64;
2611                let padding_mask = 0xffffffffffff0000u64;
2612                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
2613            }
2614            Ok(())
2615        }
2616    }
2617    unsafe impl<
2618            D: fidl::encoding::ResourceDialect,
2619            T0: fidl::encoding::Encode<i64, D>,
2620            T1: fidl::encoding::Encode<u16, D>,
2621        > fidl::encoding::Encode<LegacyJoiningMakeJoinableRequest, D> for (T0, T1)
2622    {
2623        #[inline]
2624        unsafe fn encode(
2625            self,
2626            encoder: &mut fidl::encoding::Encoder<'_, D>,
2627            offset: usize,
2628            depth: fidl::encoding::Depth,
2629        ) -> fidl::Result<()> {
2630            encoder.debug_check_bounds::<LegacyJoiningMakeJoinableRequest>(offset);
2631            // Zero out padding regions. There's no need to apply masks
2632            // because the unmasked parts will be overwritten by fields.
2633            unsafe {
2634                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
2635                (ptr as *mut u64).write_unaligned(0);
2636            }
2637            // Write the fields.
2638            self.0.encode(encoder, offset + 0, depth)?;
2639            self.1.encode(encoder, offset + 8, depth)?;
2640            Ok(())
2641        }
2642    }
2643
2644    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2645        for LegacyJoiningMakeJoinableRequest
2646    {
2647        #[inline(always)]
2648        fn new_empty() -> Self {
2649            Self { duration: fidl::new_empty!(i64, D), port: fidl::new_empty!(u16, D) }
2650        }
2651
2652        #[inline]
2653        unsafe fn decode(
2654            &mut self,
2655            decoder: &mut fidl::encoding::Decoder<'_, D>,
2656            offset: usize,
2657            _depth: fidl::encoding::Depth,
2658        ) -> fidl::Result<()> {
2659            decoder.debug_check_bounds::<Self>(offset);
2660            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2661            // Verify that padding bytes are zero.
2662            let ptr = unsafe { buf_ptr.offset(8) };
2663            let padval = unsafe { (ptr as *const u64).read_unaligned() };
2664            let mask = 0xffffffffffff0000u64;
2665            let maskedval = padval & mask;
2666            if maskedval != 0 {
2667                return Err(fidl::Error::NonZeroPadding {
2668                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
2669                });
2670            }
2671            // Copy from the buffer into the object.
2672            unsafe {
2673                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
2674            }
2675            Ok(())
2676        }
2677    }
2678
2679    impl fidl::encoding::ValueTypeMarker for ProvisioningMonitorWatchProgressResponse {
2680        type Borrowed<'a> = &'a Self;
2681        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2682            value
2683        }
2684    }
2685
2686    unsafe impl fidl::encoding::TypeMarker for ProvisioningMonitorWatchProgressResponse {
2687        type Owned = Self;
2688
2689        #[inline(always)]
2690        fn inline_align(_context: fidl::encoding::Context) -> usize {
2691            8
2692        }
2693
2694        #[inline(always)]
2695        fn inline_size(_context: fidl::encoding::Context) -> usize {
2696            16
2697        }
2698    }
2699
2700    unsafe impl<D: fidl::encoding::ResourceDialect>
2701        fidl::encoding::Encode<ProvisioningMonitorWatchProgressResponse, D>
2702        for &ProvisioningMonitorWatchProgressResponse
2703    {
2704        #[inline]
2705        unsafe fn encode(
2706            self,
2707            encoder: &mut fidl::encoding::Encoder<'_, D>,
2708            offset: usize,
2709            _depth: fidl::encoding::Depth,
2710        ) -> fidl::Result<()> {
2711            encoder.debug_check_bounds::<ProvisioningMonitorWatchProgressResponse>(offset);
2712            // Delegate to tuple encoding.
2713            fidl::encoding::Encode::<ProvisioningMonitorWatchProgressResponse, D>::encode(
2714                (<ProvisioningProgress as fidl::encoding::ValueTypeMarker>::borrow(&self.progress),),
2715                encoder,
2716                offset,
2717                _depth,
2718            )
2719        }
2720    }
2721    unsafe impl<
2722            D: fidl::encoding::ResourceDialect,
2723            T0: fidl::encoding::Encode<ProvisioningProgress, D>,
2724        > fidl::encoding::Encode<ProvisioningMonitorWatchProgressResponse, D> for (T0,)
2725    {
2726        #[inline]
2727        unsafe fn encode(
2728            self,
2729            encoder: &mut fidl::encoding::Encoder<'_, D>,
2730            offset: usize,
2731            depth: fidl::encoding::Depth,
2732        ) -> fidl::Result<()> {
2733            encoder.debug_check_bounds::<ProvisioningMonitorWatchProgressResponse>(offset);
2734            // Zero out padding regions. There's no need to apply masks
2735            // because the unmasked parts will be overwritten by fields.
2736            // Write the fields.
2737            self.0.encode(encoder, offset + 0, depth)?;
2738            Ok(())
2739        }
2740    }
2741
2742    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2743        for ProvisioningMonitorWatchProgressResponse
2744    {
2745        #[inline(always)]
2746        fn new_empty() -> Self {
2747            Self { progress: fidl::new_empty!(ProvisioningProgress, D) }
2748        }
2749
2750        #[inline]
2751        unsafe fn decode(
2752            &mut self,
2753            decoder: &mut fidl::encoding::Decoder<'_, D>,
2754            offset: usize,
2755            _depth: fidl::encoding::Depth,
2756        ) -> fidl::Result<()> {
2757            decoder.debug_check_bounds::<Self>(offset);
2758            // Verify that padding bytes are zero.
2759            fidl::decode!(
2760                ProvisioningProgress,
2761                D,
2762                &mut self.progress,
2763                decoder,
2764                offset + 0,
2765                _depth
2766            )?;
2767            Ok(())
2768        }
2769    }
2770
2771    impl fidl::encoding::ValueTypeMarker for TelemetryProviderGetTelemetryResponse {
2772        type Borrowed<'a> = &'a Self;
2773        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2774            value
2775        }
2776    }
2777
2778    unsafe impl fidl::encoding::TypeMarker for TelemetryProviderGetTelemetryResponse {
2779        type Owned = Self;
2780
2781        #[inline(always)]
2782        fn inline_align(_context: fidl::encoding::Context) -> usize {
2783            8
2784        }
2785
2786        #[inline(always)]
2787        fn inline_size(_context: fidl::encoding::Context) -> usize {
2788            16
2789        }
2790    }
2791
2792    unsafe impl<D: fidl::encoding::ResourceDialect>
2793        fidl::encoding::Encode<TelemetryProviderGetTelemetryResponse, D>
2794        for &TelemetryProviderGetTelemetryResponse
2795    {
2796        #[inline]
2797        unsafe fn encode(
2798            self,
2799            encoder: &mut fidl::encoding::Encoder<'_, D>,
2800            offset: usize,
2801            _depth: fidl::encoding::Depth,
2802        ) -> fidl::Result<()> {
2803            encoder.debug_check_bounds::<TelemetryProviderGetTelemetryResponse>(offset);
2804            // Delegate to tuple encoding.
2805            fidl::encoding::Encode::<TelemetryProviderGetTelemetryResponse, D>::encode(
2806                (<Telemetry as fidl::encoding::ValueTypeMarker>::borrow(&self.telemetry),),
2807                encoder,
2808                offset,
2809                _depth,
2810            )
2811        }
2812    }
2813    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Telemetry, D>>
2814        fidl::encoding::Encode<TelemetryProviderGetTelemetryResponse, D> for (T0,)
2815    {
2816        #[inline]
2817        unsafe fn encode(
2818            self,
2819            encoder: &mut fidl::encoding::Encoder<'_, D>,
2820            offset: usize,
2821            depth: fidl::encoding::Depth,
2822        ) -> fidl::Result<()> {
2823            encoder.debug_check_bounds::<TelemetryProviderGetTelemetryResponse>(offset);
2824            // Zero out padding regions. There's no need to apply masks
2825            // because the unmasked parts will be overwritten by fields.
2826            // Write the fields.
2827            self.0.encode(encoder, offset + 0, depth)?;
2828            Ok(())
2829        }
2830    }
2831
2832    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2833        for TelemetryProviderGetTelemetryResponse
2834    {
2835        #[inline(always)]
2836        fn new_empty() -> Self {
2837            Self { telemetry: fidl::new_empty!(Telemetry, D) }
2838        }
2839
2840        #[inline]
2841        unsafe fn decode(
2842            &mut self,
2843            decoder: &mut fidl::encoding::Decoder<'_, D>,
2844            offset: usize,
2845            _depth: fidl::encoding::Depth,
2846        ) -> fidl::Result<()> {
2847            decoder.debug_check_bounds::<Self>(offset);
2848            // Verify that padding bytes are zero.
2849            fidl::decode!(Telemetry, D, &mut self.telemetry, decoder, offset + 0, _depth)?;
2850            Ok(())
2851        }
2852    }
2853
2854    impl BeaconInfo {
2855        #[inline(always)]
2856        fn max_ordinal_present(&self) -> u64 {
2857            if let Some(_) = self.lqi {
2858                return 4;
2859            }
2860            if let Some(_) = self.rssi {
2861                return 3;
2862            }
2863            if let Some(_) = self.identity {
2864                return 2;
2865            }
2866            if let Some(_) = self.address {
2867                return 1;
2868            }
2869            0
2870        }
2871    }
2872
2873    impl fidl::encoding::ValueTypeMarker for BeaconInfo {
2874        type Borrowed<'a> = &'a Self;
2875        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2876            value
2877        }
2878    }
2879
2880    unsafe impl fidl::encoding::TypeMarker for BeaconInfo {
2881        type Owned = Self;
2882
2883        #[inline(always)]
2884        fn inline_align(_context: fidl::encoding::Context) -> usize {
2885            8
2886        }
2887
2888        #[inline(always)]
2889        fn inline_size(_context: fidl::encoding::Context) -> usize {
2890            16
2891        }
2892    }
2893
2894    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BeaconInfo, D>
2895        for &BeaconInfo
2896    {
2897        unsafe fn encode(
2898            self,
2899            encoder: &mut fidl::encoding::Encoder<'_, D>,
2900            offset: usize,
2901            mut depth: fidl::encoding::Depth,
2902        ) -> fidl::Result<()> {
2903            encoder.debug_check_bounds::<BeaconInfo>(offset);
2904            // Vector header
2905            let max_ordinal: u64 = self.max_ordinal_present();
2906            encoder.write_num(max_ordinal, offset);
2907            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2908            // Calling encoder.out_of_line_offset(0) is not allowed.
2909            if max_ordinal == 0 {
2910                return Ok(());
2911            }
2912            depth.increment()?;
2913            let envelope_size = 8;
2914            let bytes_len = max_ordinal as usize * envelope_size;
2915            #[allow(unused_variables)]
2916            let offset = encoder.out_of_line_offset(bytes_len);
2917            let mut _prev_end_offset: usize = 0;
2918            if 1 > max_ordinal {
2919                return Ok(());
2920            }
2921
2922            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2923            // are envelope_size bytes.
2924            let cur_offset: usize = (1 - 1) * envelope_size;
2925
2926            // Zero reserved fields.
2927            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2928
2929            // Safety:
2930            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2931            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2932            //   envelope_size bytes, there is always sufficient room.
2933            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_lowpan__common::MacAddress, D>(
2934            self.address.as_ref().map(<fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
2935            encoder, offset + cur_offset, depth
2936        )?;
2937
2938            _prev_end_offset = cur_offset + envelope_size;
2939            if 2 > max_ordinal {
2940                return Ok(());
2941            }
2942
2943            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2944            // are envelope_size bytes.
2945            let cur_offset: usize = (2 - 1) * envelope_size;
2946
2947            // Zero reserved fields.
2948            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2949
2950            // Safety:
2951            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2952            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2953            //   envelope_size bytes, there is always sufficient room.
2954            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_lowpan_device__common::Identity, D>(
2955            self.identity.as_ref().map(<fidl_fuchsia_lowpan_device__common::Identity as fidl::encoding::ValueTypeMarker>::borrow),
2956            encoder, offset + cur_offset, depth
2957        )?;
2958
2959            _prev_end_offset = cur_offset + envelope_size;
2960            if 3 > max_ordinal {
2961                return Ok(());
2962            }
2963
2964            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2965            // are envelope_size bytes.
2966            let cur_offset: usize = (3 - 1) * envelope_size;
2967
2968            // Zero reserved fields.
2969            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2970
2971            // Safety:
2972            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2973            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2974            //   envelope_size bytes, there is always sufficient room.
2975            fidl::encoding::encode_in_envelope_optional::<i8, D>(
2976                self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
2977                encoder,
2978                offset + cur_offset,
2979                depth,
2980            )?;
2981
2982            _prev_end_offset = cur_offset + envelope_size;
2983            if 4 > max_ordinal {
2984                return Ok(());
2985            }
2986
2987            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2988            // are envelope_size bytes.
2989            let cur_offset: usize = (4 - 1) * envelope_size;
2990
2991            // Zero reserved fields.
2992            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2993
2994            // Safety:
2995            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2996            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2997            //   envelope_size bytes, there is always sufficient room.
2998            fidl::encoding::encode_in_envelope_optional::<u8, D>(
2999                self.lqi.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
3000                encoder,
3001                offset + cur_offset,
3002                depth,
3003            )?;
3004
3005            _prev_end_offset = cur_offset + envelope_size;
3006
3007            Ok(())
3008        }
3009    }
3010
3011    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BeaconInfo {
3012        #[inline(always)]
3013        fn new_empty() -> Self {
3014            Self::default()
3015        }
3016
3017        unsafe fn decode(
3018            &mut self,
3019            decoder: &mut fidl::encoding::Decoder<'_, D>,
3020            offset: usize,
3021            mut depth: fidl::encoding::Depth,
3022        ) -> fidl::Result<()> {
3023            decoder.debug_check_bounds::<Self>(offset);
3024            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3025                None => return Err(fidl::Error::NotNullable),
3026                Some(len) => len,
3027            };
3028            // Calling decoder.out_of_line_offset(0) is not allowed.
3029            if len == 0 {
3030                return Ok(());
3031            };
3032            depth.increment()?;
3033            let envelope_size = 8;
3034            let bytes_len = len * envelope_size;
3035            let offset = decoder.out_of_line_offset(bytes_len)?;
3036            // Decode the envelope for each type.
3037            let mut _next_ordinal_to_read = 0;
3038            let mut next_offset = offset;
3039            let end_offset = offset + bytes_len;
3040            _next_ordinal_to_read += 1;
3041            if next_offset >= end_offset {
3042                return Ok(());
3043            }
3044
3045            // Decode unknown envelopes for gaps in ordinals.
3046            while _next_ordinal_to_read < 1 {
3047                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3048                _next_ordinal_to_read += 1;
3049                next_offset += envelope_size;
3050            }
3051
3052            let next_out_of_line = decoder.next_out_of_line();
3053            let handles_before = decoder.remaining_handles();
3054            if let Some((inlined, num_bytes, num_handles)) =
3055                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3056            {
3057                let member_inline_size = <fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3058                if inlined != (member_inline_size <= 4) {
3059                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3060                }
3061                let inner_offset;
3062                let mut inner_depth = depth.clone();
3063                if inlined {
3064                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3065                    inner_offset = next_offset;
3066                } else {
3067                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3068                    inner_depth.increment()?;
3069                }
3070                let val_ref = self.address.get_or_insert_with(|| {
3071                    fidl::new_empty!(fidl_fuchsia_lowpan__common::MacAddress, D)
3072                });
3073                fidl::decode!(
3074                    fidl_fuchsia_lowpan__common::MacAddress,
3075                    D,
3076                    val_ref,
3077                    decoder,
3078                    inner_offset,
3079                    inner_depth
3080                )?;
3081                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3082                {
3083                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3084                }
3085                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3086                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3087                }
3088            }
3089
3090            next_offset += envelope_size;
3091            _next_ordinal_to_read += 1;
3092            if next_offset >= end_offset {
3093                return Ok(());
3094            }
3095
3096            // Decode unknown envelopes for gaps in ordinals.
3097            while _next_ordinal_to_read < 2 {
3098                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3099                _next_ordinal_to_read += 1;
3100                next_offset += envelope_size;
3101            }
3102
3103            let next_out_of_line = decoder.next_out_of_line();
3104            let handles_before = decoder.remaining_handles();
3105            if let Some((inlined, num_bytes, num_handles)) =
3106                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3107            {
3108                let member_inline_size = <fidl_fuchsia_lowpan_device__common::Identity as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3109                if inlined != (member_inline_size <= 4) {
3110                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3111                }
3112                let inner_offset;
3113                let mut inner_depth = depth.clone();
3114                if inlined {
3115                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3116                    inner_offset = next_offset;
3117                } else {
3118                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3119                    inner_depth.increment()?;
3120                }
3121                let val_ref = self.identity.get_or_insert_with(|| {
3122                    fidl::new_empty!(fidl_fuchsia_lowpan_device__common::Identity, D)
3123                });
3124                fidl::decode!(
3125                    fidl_fuchsia_lowpan_device__common::Identity,
3126                    D,
3127                    val_ref,
3128                    decoder,
3129                    inner_offset,
3130                    inner_depth
3131                )?;
3132                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3133                {
3134                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3135                }
3136                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3137                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3138                }
3139            }
3140
3141            next_offset += envelope_size;
3142            _next_ordinal_to_read += 1;
3143            if next_offset >= end_offset {
3144                return Ok(());
3145            }
3146
3147            // Decode unknown envelopes for gaps in ordinals.
3148            while _next_ordinal_to_read < 3 {
3149                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3150                _next_ordinal_to_read += 1;
3151                next_offset += envelope_size;
3152            }
3153
3154            let next_out_of_line = decoder.next_out_of_line();
3155            let handles_before = decoder.remaining_handles();
3156            if let Some((inlined, num_bytes, num_handles)) =
3157                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3158            {
3159                let member_inline_size =
3160                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3161                if inlined != (member_inline_size <= 4) {
3162                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3163                }
3164                let inner_offset;
3165                let mut inner_depth = depth.clone();
3166                if inlined {
3167                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3168                    inner_offset = next_offset;
3169                } else {
3170                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3171                    inner_depth.increment()?;
3172                }
3173                let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
3174                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
3175                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3176                {
3177                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3178                }
3179                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3180                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3181                }
3182            }
3183
3184            next_offset += envelope_size;
3185            _next_ordinal_to_read += 1;
3186            if next_offset >= end_offset {
3187                return Ok(());
3188            }
3189
3190            // Decode unknown envelopes for gaps in ordinals.
3191            while _next_ordinal_to_read < 4 {
3192                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3193                _next_ordinal_to_read += 1;
3194                next_offset += envelope_size;
3195            }
3196
3197            let next_out_of_line = decoder.next_out_of_line();
3198            let handles_before = decoder.remaining_handles();
3199            if let Some((inlined, num_bytes, num_handles)) =
3200                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3201            {
3202                let member_inline_size =
3203                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3204                if inlined != (member_inline_size <= 4) {
3205                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3206                }
3207                let inner_offset;
3208                let mut inner_depth = depth.clone();
3209                if inlined {
3210                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3211                    inner_offset = next_offset;
3212                } else {
3213                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3214                    inner_depth.increment()?;
3215                }
3216                let val_ref = self.lqi.get_or_insert_with(|| fidl::new_empty!(u8, D));
3217                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
3218                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3219                {
3220                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3221                }
3222                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3223                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3224                }
3225            }
3226
3227            next_offset += envelope_size;
3228
3229            // Decode the remaining unknown envelopes.
3230            while next_offset < end_offset {
3231                _next_ordinal_to_read += 1;
3232                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3233                next_offset += envelope_size;
3234            }
3235
3236            Ok(())
3237        }
3238    }
3239
3240    impl BorderRoutingCounters {
3241        #[inline(always)]
3242        fn max_ordinal_present(&self) -> u64 {
3243            if let Some(_) = self.outbound_internet_bytes {
3244                return 18;
3245            }
3246            if let Some(_) = self.outbound_internet_packets {
3247                return 17;
3248            }
3249            if let Some(_) = self.inbound_internet_bytes {
3250                return 16;
3251            }
3252            if let Some(_) = self.inbound_internet_packets {
3253                return 15;
3254            }
3255            if let Some(_) = self.rs_tx_failure {
3256                return 14;
3257            }
3258            if let Some(_) = self.rs_tx_success {
3259                return 13;
3260            }
3261            if let Some(_) = self.rs_rx {
3262                return 12;
3263            }
3264            if let Some(_) = self.ra_tx_failure {
3265                return 11;
3266            }
3267            if let Some(_) = self.ra_tx_success {
3268                return 10;
3269            }
3270            if let Some(_) = self.ra_rx {
3271                return 9;
3272            }
3273            if let Some(_) = self.outbound_multicast_bytes {
3274                return 8;
3275            }
3276            if let Some(_) = self.outbound_multicast_packets {
3277                return 7;
3278            }
3279            if let Some(_) = self.outbound_unicast_bytes {
3280                return 6;
3281            }
3282            if let Some(_) = self.outbound_unicast_packets {
3283                return 5;
3284            }
3285            if let Some(_) = self.inbound_multicast_bytes {
3286                return 4;
3287            }
3288            if let Some(_) = self.inbound_multicast_packets {
3289                return 3;
3290            }
3291            if let Some(_) = self.inbound_unicast_bytes {
3292                return 2;
3293            }
3294            if let Some(_) = self.inbound_unicast_packets {
3295                return 1;
3296            }
3297            0
3298        }
3299    }
3300
3301    impl fidl::encoding::ValueTypeMarker for BorderRoutingCounters {
3302        type Borrowed<'a> = &'a Self;
3303        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3304            value
3305        }
3306    }
3307
3308    unsafe impl fidl::encoding::TypeMarker for BorderRoutingCounters {
3309        type Owned = Self;
3310
3311        #[inline(always)]
3312        fn inline_align(_context: fidl::encoding::Context) -> usize {
3313            8
3314        }
3315
3316        #[inline(always)]
3317        fn inline_size(_context: fidl::encoding::Context) -> usize {
3318            16
3319        }
3320    }
3321
3322    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BorderRoutingCounters, D>
3323        for &BorderRoutingCounters
3324    {
3325        unsafe fn encode(
3326            self,
3327            encoder: &mut fidl::encoding::Encoder<'_, D>,
3328            offset: usize,
3329            mut depth: fidl::encoding::Depth,
3330        ) -> fidl::Result<()> {
3331            encoder.debug_check_bounds::<BorderRoutingCounters>(offset);
3332            // Vector header
3333            let max_ordinal: u64 = self.max_ordinal_present();
3334            encoder.write_num(max_ordinal, offset);
3335            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3336            // Calling encoder.out_of_line_offset(0) is not allowed.
3337            if max_ordinal == 0 {
3338                return Ok(());
3339            }
3340            depth.increment()?;
3341            let envelope_size = 8;
3342            let bytes_len = max_ordinal as usize * envelope_size;
3343            #[allow(unused_variables)]
3344            let offset = encoder.out_of_line_offset(bytes_len);
3345            let mut _prev_end_offset: usize = 0;
3346            if 1 > max_ordinal {
3347                return Ok(());
3348            }
3349
3350            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3351            // are envelope_size bytes.
3352            let cur_offset: usize = (1 - 1) * envelope_size;
3353
3354            // Zero reserved fields.
3355            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3356
3357            // Safety:
3358            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3359            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3360            //   envelope_size bytes, there is always sufficient room.
3361            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3362                self.inbound_unicast_packets
3363                    .as_ref()
3364                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3365                encoder,
3366                offset + cur_offset,
3367                depth,
3368            )?;
3369
3370            _prev_end_offset = cur_offset + envelope_size;
3371            if 2 > max_ordinal {
3372                return Ok(());
3373            }
3374
3375            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3376            // are envelope_size bytes.
3377            let cur_offset: usize = (2 - 1) * envelope_size;
3378
3379            // Zero reserved fields.
3380            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3381
3382            // Safety:
3383            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3384            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3385            //   envelope_size bytes, there is always sufficient room.
3386            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3387                self.inbound_unicast_bytes
3388                    .as_ref()
3389                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3390                encoder,
3391                offset + cur_offset,
3392                depth,
3393            )?;
3394
3395            _prev_end_offset = cur_offset + envelope_size;
3396            if 3 > max_ordinal {
3397                return Ok(());
3398            }
3399
3400            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3401            // are envelope_size bytes.
3402            let cur_offset: usize = (3 - 1) * envelope_size;
3403
3404            // Zero reserved fields.
3405            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3406
3407            // Safety:
3408            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3409            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3410            //   envelope_size bytes, there is always sufficient room.
3411            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3412                self.inbound_multicast_packets
3413                    .as_ref()
3414                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3415                encoder,
3416                offset + cur_offset,
3417                depth,
3418            )?;
3419
3420            _prev_end_offset = cur_offset + envelope_size;
3421            if 4 > max_ordinal {
3422                return Ok(());
3423            }
3424
3425            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3426            // are envelope_size bytes.
3427            let cur_offset: usize = (4 - 1) * envelope_size;
3428
3429            // Zero reserved fields.
3430            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3431
3432            // Safety:
3433            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3434            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3435            //   envelope_size bytes, there is always sufficient room.
3436            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3437                self.inbound_multicast_bytes
3438                    .as_ref()
3439                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3440                encoder,
3441                offset + cur_offset,
3442                depth,
3443            )?;
3444
3445            _prev_end_offset = cur_offset + envelope_size;
3446            if 5 > max_ordinal {
3447                return Ok(());
3448            }
3449
3450            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3451            // are envelope_size bytes.
3452            let cur_offset: usize = (5 - 1) * envelope_size;
3453
3454            // Zero reserved fields.
3455            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3456
3457            // Safety:
3458            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3459            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3460            //   envelope_size bytes, there is always sufficient room.
3461            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3462                self.outbound_unicast_packets
3463                    .as_ref()
3464                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3465                encoder,
3466                offset + cur_offset,
3467                depth,
3468            )?;
3469
3470            _prev_end_offset = cur_offset + envelope_size;
3471            if 6 > max_ordinal {
3472                return Ok(());
3473            }
3474
3475            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3476            // are envelope_size bytes.
3477            let cur_offset: usize = (6 - 1) * envelope_size;
3478
3479            // Zero reserved fields.
3480            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3481
3482            // Safety:
3483            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3484            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3485            //   envelope_size bytes, there is always sufficient room.
3486            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3487                self.outbound_unicast_bytes
3488                    .as_ref()
3489                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3490                encoder,
3491                offset + cur_offset,
3492                depth,
3493            )?;
3494
3495            _prev_end_offset = cur_offset + envelope_size;
3496            if 7 > max_ordinal {
3497                return Ok(());
3498            }
3499
3500            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3501            // are envelope_size bytes.
3502            let cur_offset: usize = (7 - 1) * envelope_size;
3503
3504            // Zero reserved fields.
3505            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3506
3507            // Safety:
3508            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3509            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3510            //   envelope_size bytes, there is always sufficient room.
3511            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3512                self.outbound_multicast_packets
3513                    .as_ref()
3514                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3515                encoder,
3516                offset + cur_offset,
3517                depth,
3518            )?;
3519
3520            _prev_end_offset = cur_offset + envelope_size;
3521            if 8 > max_ordinal {
3522                return Ok(());
3523            }
3524
3525            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3526            // are envelope_size bytes.
3527            let cur_offset: usize = (8 - 1) * envelope_size;
3528
3529            // Zero reserved fields.
3530            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3531
3532            // Safety:
3533            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3534            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3535            //   envelope_size bytes, there is always sufficient room.
3536            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3537                self.outbound_multicast_bytes
3538                    .as_ref()
3539                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3540                encoder,
3541                offset + cur_offset,
3542                depth,
3543            )?;
3544
3545            _prev_end_offset = cur_offset + envelope_size;
3546            if 9 > max_ordinal {
3547                return Ok(());
3548            }
3549
3550            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3551            // are envelope_size bytes.
3552            let cur_offset: usize = (9 - 1) * envelope_size;
3553
3554            // Zero reserved fields.
3555            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3556
3557            // Safety:
3558            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3559            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3560            //   envelope_size bytes, there is always sufficient room.
3561            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3562                self.ra_rx.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3563                encoder,
3564                offset + cur_offset,
3565                depth,
3566            )?;
3567
3568            _prev_end_offset = cur_offset + envelope_size;
3569            if 10 > max_ordinal {
3570                return Ok(());
3571            }
3572
3573            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3574            // are envelope_size bytes.
3575            let cur_offset: usize = (10 - 1) * envelope_size;
3576
3577            // Zero reserved fields.
3578            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3579
3580            // Safety:
3581            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3582            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3583            //   envelope_size bytes, there is always sufficient room.
3584            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3585                self.ra_tx_success.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3586                encoder,
3587                offset + cur_offset,
3588                depth,
3589            )?;
3590
3591            _prev_end_offset = cur_offset + envelope_size;
3592            if 11 > max_ordinal {
3593                return Ok(());
3594            }
3595
3596            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3597            // are envelope_size bytes.
3598            let cur_offset: usize = (11 - 1) * envelope_size;
3599
3600            // Zero reserved fields.
3601            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3602
3603            // Safety:
3604            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3605            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3606            //   envelope_size bytes, there is always sufficient room.
3607            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3608                self.ra_tx_failure.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3609                encoder,
3610                offset + cur_offset,
3611                depth,
3612            )?;
3613
3614            _prev_end_offset = cur_offset + envelope_size;
3615            if 12 > max_ordinal {
3616                return Ok(());
3617            }
3618
3619            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3620            // are envelope_size bytes.
3621            let cur_offset: usize = (12 - 1) * envelope_size;
3622
3623            // Zero reserved fields.
3624            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3625
3626            // Safety:
3627            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3628            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3629            //   envelope_size bytes, there is always sufficient room.
3630            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3631                self.rs_rx.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3632                encoder,
3633                offset + cur_offset,
3634                depth,
3635            )?;
3636
3637            _prev_end_offset = cur_offset + envelope_size;
3638            if 13 > max_ordinal {
3639                return Ok(());
3640            }
3641
3642            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3643            // are envelope_size bytes.
3644            let cur_offset: usize = (13 - 1) * envelope_size;
3645
3646            // Zero reserved fields.
3647            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3648
3649            // Safety:
3650            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3651            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3652            //   envelope_size bytes, there is always sufficient room.
3653            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3654                self.rs_tx_success.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3655                encoder,
3656                offset + cur_offset,
3657                depth,
3658            )?;
3659
3660            _prev_end_offset = cur_offset + envelope_size;
3661            if 14 > max_ordinal {
3662                return Ok(());
3663            }
3664
3665            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3666            // are envelope_size bytes.
3667            let cur_offset: usize = (14 - 1) * envelope_size;
3668
3669            // Zero reserved fields.
3670            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3671
3672            // Safety:
3673            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3674            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3675            //   envelope_size bytes, there is always sufficient room.
3676            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3677                self.rs_tx_failure.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3678                encoder,
3679                offset + cur_offset,
3680                depth,
3681            )?;
3682
3683            _prev_end_offset = cur_offset + envelope_size;
3684            if 15 > max_ordinal {
3685                return Ok(());
3686            }
3687
3688            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3689            // are envelope_size bytes.
3690            let cur_offset: usize = (15 - 1) * envelope_size;
3691
3692            // Zero reserved fields.
3693            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3694
3695            // Safety:
3696            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3697            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3698            //   envelope_size bytes, there is always sufficient room.
3699            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3700                self.inbound_internet_packets
3701                    .as_ref()
3702                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3703                encoder,
3704                offset + cur_offset,
3705                depth,
3706            )?;
3707
3708            _prev_end_offset = cur_offset + envelope_size;
3709            if 16 > max_ordinal {
3710                return Ok(());
3711            }
3712
3713            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3714            // are envelope_size bytes.
3715            let cur_offset: usize = (16 - 1) * envelope_size;
3716
3717            // Zero reserved fields.
3718            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3719
3720            // Safety:
3721            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3722            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3723            //   envelope_size bytes, there is always sufficient room.
3724            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3725                self.inbound_internet_bytes
3726                    .as_ref()
3727                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3728                encoder,
3729                offset + cur_offset,
3730                depth,
3731            )?;
3732
3733            _prev_end_offset = cur_offset + envelope_size;
3734            if 17 > max_ordinal {
3735                return Ok(());
3736            }
3737
3738            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3739            // are envelope_size bytes.
3740            let cur_offset: usize = (17 - 1) * envelope_size;
3741
3742            // Zero reserved fields.
3743            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3744
3745            // Safety:
3746            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3747            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3748            //   envelope_size bytes, there is always sufficient room.
3749            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3750                self.outbound_internet_packets
3751                    .as_ref()
3752                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3753                encoder,
3754                offset + cur_offset,
3755                depth,
3756            )?;
3757
3758            _prev_end_offset = cur_offset + envelope_size;
3759            if 18 > max_ordinal {
3760                return Ok(());
3761            }
3762
3763            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3764            // are envelope_size bytes.
3765            let cur_offset: usize = (18 - 1) * envelope_size;
3766
3767            // Zero reserved fields.
3768            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3769
3770            // Safety:
3771            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3772            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3773            //   envelope_size bytes, there is always sufficient room.
3774            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3775                self.outbound_internet_bytes
3776                    .as_ref()
3777                    .map(<u64 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 BorderRoutingCounters {
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                    <u64 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 =
3850                    self.inbound_unicast_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
3851                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3852                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3853                {
3854                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3855                }
3856                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3857                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3858                }
3859            }
3860
3861            next_offset += envelope_size;
3862            _next_ordinal_to_read += 1;
3863            if next_offset >= end_offset {
3864                return Ok(());
3865            }
3866
3867            // Decode unknown envelopes for gaps in ordinals.
3868            while _next_ordinal_to_read < 2 {
3869                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3870                _next_ordinal_to_read += 1;
3871                next_offset += envelope_size;
3872            }
3873
3874            let next_out_of_line = decoder.next_out_of_line();
3875            let handles_before = decoder.remaining_handles();
3876            if let Some((inlined, num_bytes, num_handles)) =
3877                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3878            {
3879                let member_inline_size =
3880                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3881                if inlined != (member_inline_size <= 4) {
3882                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3883                }
3884                let inner_offset;
3885                let mut inner_depth = depth.clone();
3886                if inlined {
3887                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3888                    inner_offset = next_offset;
3889                } else {
3890                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3891                    inner_depth.increment()?;
3892                }
3893                let val_ref =
3894                    self.inbound_unicast_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
3895                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3896                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3897                {
3898                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3899                }
3900                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3901                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3902                }
3903            }
3904
3905            next_offset += envelope_size;
3906            _next_ordinal_to_read += 1;
3907            if next_offset >= end_offset {
3908                return Ok(());
3909            }
3910
3911            // Decode unknown envelopes for gaps in ordinals.
3912            while _next_ordinal_to_read < 3 {
3913                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3914                _next_ordinal_to_read += 1;
3915                next_offset += envelope_size;
3916            }
3917
3918            let next_out_of_line = decoder.next_out_of_line();
3919            let handles_before = decoder.remaining_handles();
3920            if let Some((inlined, num_bytes, num_handles)) =
3921                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3922            {
3923                let member_inline_size =
3924                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3925                if inlined != (member_inline_size <= 4) {
3926                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3927                }
3928                let inner_offset;
3929                let mut inner_depth = depth.clone();
3930                if inlined {
3931                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3932                    inner_offset = next_offset;
3933                } else {
3934                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3935                    inner_depth.increment()?;
3936                }
3937                let val_ref =
3938                    self.inbound_multicast_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
3939                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3940                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3941                {
3942                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3943                }
3944                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3945                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3946                }
3947            }
3948
3949            next_offset += envelope_size;
3950            _next_ordinal_to_read += 1;
3951            if next_offset >= end_offset {
3952                return Ok(());
3953            }
3954
3955            // Decode unknown envelopes for gaps in ordinals.
3956            while _next_ordinal_to_read < 4 {
3957                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3958                _next_ordinal_to_read += 1;
3959                next_offset += envelope_size;
3960            }
3961
3962            let next_out_of_line = decoder.next_out_of_line();
3963            let handles_before = decoder.remaining_handles();
3964            if let Some((inlined, num_bytes, num_handles)) =
3965                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3966            {
3967                let member_inline_size =
3968                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3969                if inlined != (member_inline_size <= 4) {
3970                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3971                }
3972                let inner_offset;
3973                let mut inner_depth = depth.clone();
3974                if inlined {
3975                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3976                    inner_offset = next_offset;
3977                } else {
3978                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3979                    inner_depth.increment()?;
3980                }
3981                let val_ref =
3982                    self.inbound_multicast_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
3983                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3984                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3985                {
3986                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3987                }
3988                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3989                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3990                }
3991            }
3992
3993            next_offset += envelope_size;
3994            _next_ordinal_to_read += 1;
3995            if next_offset >= end_offset {
3996                return Ok(());
3997            }
3998
3999            // Decode unknown envelopes for gaps in ordinals.
4000            while _next_ordinal_to_read < 5 {
4001                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4002                _next_ordinal_to_read += 1;
4003                next_offset += envelope_size;
4004            }
4005
4006            let next_out_of_line = decoder.next_out_of_line();
4007            let handles_before = decoder.remaining_handles();
4008            if let Some((inlined, num_bytes, num_handles)) =
4009                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4010            {
4011                let member_inline_size =
4012                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4013                if inlined != (member_inline_size <= 4) {
4014                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4015                }
4016                let inner_offset;
4017                let mut inner_depth = depth.clone();
4018                if inlined {
4019                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4020                    inner_offset = next_offset;
4021                } else {
4022                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4023                    inner_depth.increment()?;
4024                }
4025                let val_ref =
4026                    self.outbound_unicast_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
4027                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4028                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4029                {
4030                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4031                }
4032                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4033                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4034                }
4035            }
4036
4037            next_offset += envelope_size;
4038            _next_ordinal_to_read += 1;
4039            if next_offset >= end_offset {
4040                return Ok(());
4041            }
4042
4043            // Decode unknown envelopes for gaps in ordinals.
4044            while _next_ordinal_to_read < 6 {
4045                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4046                _next_ordinal_to_read += 1;
4047                next_offset += envelope_size;
4048            }
4049
4050            let next_out_of_line = decoder.next_out_of_line();
4051            let handles_before = decoder.remaining_handles();
4052            if let Some((inlined, num_bytes, num_handles)) =
4053                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4054            {
4055                let member_inline_size =
4056                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4057                if inlined != (member_inline_size <= 4) {
4058                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4059                }
4060                let inner_offset;
4061                let mut inner_depth = depth.clone();
4062                if inlined {
4063                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4064                    inner_offset = next_offset;
4065                } else {
4066                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4067                    inner_depth.increment()?;
4068                }
4069                let val_ref =
4070                    self.outbound_unicast_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4071                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4072                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4073                {
4074                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4075                }
4076                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4077                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4078                }
4079            }
4080
4081            next_offset += envelope_size;
4082            _next_ordinal_to_read += 1;
4083            if next_offset >= end_offset {
4084                return Ok(());
4085            }
4086
4087            // Decode unknown envelopes for gaps in ordinals.
4088            while _next_ordinal_to_read < 7 {
4089                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4090                _next_ordinal_to_read += 1;
4091                next_offset += envelope_size;
4092            }
4093
4094            let next_out_of_line = decoder.next_out_of_line();
4095            let handles_before = decoder.remaining_handles();
4096            if let Some((inlined, num_bytes, num_handles)) =
4097                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4098            {
4099                let member_inline_size =
4100                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4101                if inlined != (member_inline_size <= 4) {
4102                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4103                }
4104                let inner_offset;
4105                let mut inner_depth = depth.clone();
4106                if inlined {
4107                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4108                    inner_offset = next_offset;
4109                } else {
4110                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4111                    inner_depth.increment()?;
4112                }
4113                let val_ref =
4114                    self.outbound_multicast_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
4115                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4116                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4117                {
4118                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4119                }
4120                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4121                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4122                }
4123            }
4124
4125            next_offset += envelope_size;
4126            _next_ordinal_to_read += 1;
4127            if next_offset >= end_offset {
4128                return Ok(());
4129            }
4130
4131            // Decode unknown envelopes for gaps in ordinals.
4132            while _next_ordinal_to_read < 8 {
4133                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4134                _next_ordinal_to_read += 1;
4135                next_offset += envelope_size;
4136            }
4137
4138            let next_out_of_line = decoder.next_out_of_line();
4139            let handles_before = decoder.remaining_handles();
4140            if let Some((inlined, num_bytes, num_handles)) =
4141                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4142            {
4143                let member_inline_size =
4144                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4145                if inlined != (member_inline_size <= 4) {
4146                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4147                }
4148                let inner_offset;
4149                let mut inner_depth = depth.clone();
4150                if inlined {
4151                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4152                    inner_offset = next_offset;
4153                } else {
4154                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4155                    inner_depth.increment()?;
4156                }
4157                let val_ref =
4158                    self.outbound_multicast_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4159                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4160                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4161                {
4162                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4163                }
4164                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4165                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4166                }
4167            }
4168
4169            next_offset += envelope_size;
4170            _next_ordinal_to_read += 1;
4171            if next_offset >= end_offset {
4172                return Ok(());
4173            }
4174
4175            // Decode unknown envelopes for gaps in ordinals.
4176            while _next_ordinal_to_read < 9 {
4177                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4178                _next_ordinal_to_read += 1;
4179                next_offset += envelope_size;
4180            }
4181
4182            let next_out_of_line = decoder.next_out_of_line();
4183            let handles_before = decoder.remaining_handles();
4184            if let Some((inlined, num_bytes, num_handles)) =
4185                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4186            {
4187                let member_inline_size =
4188                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4189                if inlined != (member_inline_size <= 4) {
4190                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4191                }
4192                let inner_offset;
4193                let mut inner_depth = depth.clone();
4194                if inlined {
4195                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4196                    inner_offset = next_offset;
4197                } else {
4198                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4199                    inner_depth.increment()?;
4200                }
4201                let val_ref = self.ra_rx.get_or_insert_with(|| fidl::new_empty!(u32, D));
4202                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4203                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4204                {
4205                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4206                }
4207                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4208                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4209                }
4210            }
4211
4212            next_offset += envelope_size;
4213            _next_ordinal_to_read += 1;
4214            if next_offset >= end_offset {
4215                return Ok(());
4216            }
4217
4218            // Decode unknown envelopes for gaps in ordinals.
4219            while _next_ordinal_to_read < 10 {
4220                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4221                _next_ordinal_to_read += 1;
4222                next_offset += envelope_size;
4223            }
4224
4225            let next_out_of_line = decoder.next_out_of_line();
4226            let handles_before = decoder.remaining_handles();
4227            if let Some((inlined, num_bytes, num_handles)) =
4228                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4229            {
4230                let member_inline_size =
4231                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4232                if inlined != (member_inline_size <= 4) {
4233                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4234                }
4235                let inner_offset;
4236                let mut inner_depth = depth.clone();
4237                if inlined {
4238                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4239                    inner_offset = next_offset;
4240                } else {
4241                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4242                    inner_depth.increment()?;
4243                }
4244                let val_ref = self.ra_tx_success.get_or_insert_with(|| fidl::new_empty!(u32, D));
4245                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4246                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4247                {
4248                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4249                }
4250                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4251                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4252                }
4253            }
4254
4255            next_offset += envelope_size;
4256            _next_ordinal_to_read += 1;
4257            if next_offset >= end_offset {
4258                return Ok(());
4259            }
4260
4261            // Decode unknown envelopes for gaps in ordinals.
4262            while _next_ordinal_to_read < 11 {
4263                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4264                _next_ordinal_to_read += 1;
4265                next_offset += envelope_size;
4266            }
4267
4268            let next_out_of_line = decoder.next_out_of_line();
4269            let handles_before = decoder.remaining_handles();
4270            if let Some((inlined, num_bytes, num_handles)) =
4271                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4272            {
4273                let member_inline_size =
4274                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4275                if inlined != (member_inline_size <= 4) {
4276                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4277                }
4278                let inner_offset;
4279                let mut inner_depth = depth.clone();
4280                if inlined {
4281                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4282                    inner_offset = next_offset;
4283                } else {
4284                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4285                    inner_depth.increment()?;
4286                }
4287                let val_ref = self.ra_tx_failure.get_or_insert_with(|| fidl::new_empty!(u32, D));
4288                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4289                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4290                {
4291                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4292                }
4293                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4294                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4295                }
4296            }
4297
4298            next_offset += envelope_size;
4299            _next_ordinal_to_read += 1;
4300            if next_offset >= end_offset {
4301                return Ok(());
4302            }
4303
4304            // Decode unknown envelopes for gaps in ordinals.
4305            while _next_ordinal_to_read < 12 {
4306                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4307                _next_ordinal_to_read += 1;
4308                next_offset += envelope_size;
4309            }
4310
4311            let next_out_of_line = decoder.next_out_of_line();
4312            let handles_before = decoder.remaining_handles();
4313            if let Some((inlined, num_bytes, num_handles)) =
4314                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4315            {
4316                let member_inline_size =
4317                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4318                if inlined != (member_inline_size <= 4) {
4319                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4320                }
4321                let inner_offset;
4322                let mut inner_depth = depth.clone();
4323                if inlined {
4324                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4325                    inner_offset = next_offset;
4326                } else {
4327                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4328                    inner_depth.increment()?;
4329                }
4330                let val_ref = self.rs_rx.get_or_insert_with(|| fidl::new_empty!(u32, D));
4331                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4332                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4333                {
4334                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4335                }
4336                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4337                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4338                }
4339            }
4340
4341            next_offset += envelope_size;
4342            _next_ordinal_to_read += 1;
4343            if next_offset >= end_offset {
4344                return Ok(());
4345            }
4346
4347            // Decode unknown envelopes for gaps in ordinals.
4348            while _next_ordinal_to_read < 13 {
4349                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4350                _next_ordinal_to_read += 1;
4351                next_offset += envelope_size;
4352            }
4353
4354            let next_out_of_line = decoder.next_out_of_line();
4355            let handles_before = decoder.remaining_handles();
4356            if let Some((inlined, num_bytes, num_handles)) =
4357                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4358            {
4359                let member_inline_size =
4360                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4361                if inlined != (member_inline_size <= 4) {
4362                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4363                }
4364                let inner_offset;
4365                let mut inner_depth = depth.clone();
4366                if inlined {
4367                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4368                    inner_offset = next_offset;
4369                } else {
4370                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4371                    inner_depth.increment()?;
4372                }
4373                let val_ref = self.rs_tx_success.get_or_insert_with(|| fidl::new_empty!(u32, D));
4374                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4375                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4376                {
4377                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4378                }
4379                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4380                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4381                }
4382            }
4383
4384            next_offset += envelope_size;
4385            _next_ordinal_to_read += 1;
4386            if next_offset >= end_offset {
4387                return Ok(());
4388            }
4389
4390            // Decode unknown envelopes for gaps in ordinals.
4391            while _next_ordinal_to_read < 14 {
4392                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4393                _next_ordinal_to_read += 1;
4394                next_offset += envelope_size;
4395            }
4396
4397            let next_out_of_line = decoder.next_out_of_line();
4398            let handles_before = decoder.remaining_handles();
4399            if let Some((inlined, num_bytes, num_handles)) =
4400                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4401            {
4402                let member_inline_size =
4403                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4404                if inlined != (member_inline_size <= 4) {
4405                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4406                }
4407                let inner_offset;
4408                let mut inner_depth = depth.clone();
4409                if inlined {
4410                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4411                    inner_offset = next_offset;
4412                } else {
4413                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4414                    inner_depth.increment()?;
4415                }
4416                let val_ref = self.rs_tx_failure.get_or_insert_with(|| fidl::new_empty!(u32, D));
4417                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4418                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4419                {
4420                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4421                }
4422                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4423                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4424                }
4425            }
4426
4427            next_offset += envelope_size;
4428            _next_ordinal_to_read += 1;
4429            if next_offset >= end_offset {
4430                return Ok(());
4431            }
4432
4433            // Decode unknown envelopes for gaps in ordinals.
4434            while _next_ordinal_to_read < 15 {
4435                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4436                _next_ordinal_to_read += 1;
4437                next_offset += envelope_size;
4438            }
4439
4440            let next_out_of_line = decoder.next_out_of_line();
4441            let handles_before = decoder.remaining_handles();
4442            if let Some((inlined, num_bytes, num_handles)) =
4443                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4444            {
4445                let member_inline_size =
4446                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4447                if inlined != (member_inline_size <= 4) {
4448                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4449                }
4450                let inner_offset;
4451                let mut inner_depth = depth.clone();
4452                if inlined {
4453                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4454                    inner_offset = next_offset;
4455                } else {
4456                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4457                    inner_depth.increment()?;
4458                }
4459                let val_ref =
4460                    self.inbound_internet_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
4461                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4462                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4463                {
4464                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4465                }
4466                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4467                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4468                }
4469            }
4470
4471            next_offset += envelope_size;
4472            _next_ordinal_to_read += 1;
4473            if next_offset >= end_offset {
4474                return Ok(());
4475            }
4476
4477            // Decode unknown envelopes for gaps in ordinals.
4478            while _next_ordinal_to_read < 16 {
4479                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4480                _next_ordinal_to_read += 1;
4481                next_offset += envelope_size;
4482            }
4483
4484            let next_out_of_line = decoder.next_out_of_line();
4485            let handles_before = decoder.remaining_handles();
4486            if let Some((inlined, num_bytes, num_handles)) =
4487                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4488            {
4489                let member_inline_size =
4490                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4491                if inlined != (member_inline_size <= 4) {
4492                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4493                }
4494                let inner_offset;
4495                let mut inner_depth = depth.clone();
4496                if inlined {
4497                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4498                    inner_offset = next_offset;
4499                } else {
4500                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4501                    inner_depth.increment()?;
4502                }
4503                let val_ref =
4504                    self.inbound_internet_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4505                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4506                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4507                {
4508                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4509                }
4510                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4511                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4512                }
4513            }
4514
4515            next_offset += envelope_size;
4516            _next_ordinal_to_read += 1;
4517            if next_offset >= end_offset {
4518                return Ok(());
4519            }
4520
4521            // Decode unknown envelopes for gaps in ordinals.
4522            while _next_ordinal_to_read < 17 {
4523                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4524                _next_ordinal_to_read += 1;
4525                next_offset += envelope_size;
4526            }
4527
4528            let next_out_of_line = decoder.next_out_of_line();
4529            let handles_before = decoder.remaining_handles();
4530            if let Some((inlined, num_bytes, num_handles)) =
4531                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4532            {
4533                let member_inline_size =
4534                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4535                if inlined != (member_inline_size <= 4) {
4536                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4537                }
4538                let inner_offset;
4539                let mut inner_depth = depth.clone();
4540                if inlined {
4541                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4542                    inner_offset = next_offset;
4543                } else {
4544                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4545                    inner_depth.increment()?;
4546                }
4547                let val_ref =
4548                    self.outbound_internet_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
4549                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4550                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4551                {
4552                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4553                }
4554                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4555                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4556                }
4557            }
4558
4559            next_offset += envelope_size;
4560            _next_ordinal_to_read += 1;
4561            if next_offset >= end_offset {
4562                return Ok(());
4563            }
4564
4565            // Decode unknown envelopes for gaps in ordinals.
4566            while _next_ordinal_to_read < 18 {
4567                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4568                _next_ordinal_to_read += 1;
4569                next_offset += envelope_size;
4570            }
4571
4572            let next_out_of_line = decoder.next_out_of_line();
4573            let handles_before = decoder.remaining_handles();
4574            if let Some((inlined, num_bytes, num_handles)) =
4575                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4576            {
4577                let member_inline_size =
4578                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4579                if inlined != (member_inline_size <= 4) {
4580                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4581                }
4582                let inner_offset;
4583                let mut inner_depth = depth.clone();
4584                if inlined {
4585                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4586                    inner_offset = next_offset;
4587                } else {
4588                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4589                    inner_depth.increment()?;
4590                }
4591                let val_ref =
4592                    self.outbound_internet_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4593                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4594                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4595                {
4596                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4597                }
4598                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4599                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4600                }
4601            }
4602
4603            next_offset += envelope_size;
4604
4605            // Decode the remaining unknown envelopes.
4606            while next_offset < end_offset {
4607                _next_ordinal_to_read += 1;
4608                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4609                next_offset += envelope_size;
4610            }
4611
4612            Ok(())
4613        }
4614    }
4615
4616    impl BorderRoutingNat64State {
4617        #[inline(always)]
4618        fn max_ordinal_present(&self) -> u64 {
4619            if let Some(_) = self.translator_state {
4620                return 2;
4621            }
4622            if let Some(_) = self.prefix_manager_state {
4623                return 1;
4624            }
4625            0
4626        }
4627    }
4628
4629    impl fidl::encoding::ValueTypeMarker for BorderRoutingNat64State {
4630        type Borrowed<'a> = &'a Self;
4631        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4632            value
4633        }
4634    }
4635
4636    unsafe impl fidl::encoding::TypeMarker for BorderRoutingNat64State {
4637        type Owned = Self;
4638
4639        #[inline(always)]
4640        fn inline_align(_context: fidl::encoding::Context) -> usize {
4641            8
4642        }
4643
4644        #[inline(always)]
4645        fn inline_size(_context: fidl::encoding::Context) -> usize {
4646            16
4647        }
4648    }
4649
4650    unsafe impl<D: fidl::encoding::ResourceDialect>
4651        fidl::encoding::Encode<BorderRoutingNat64State, D> for &BorderRoutingNat64State
4652    {
4653        unsafe fn encode(
4654            self,
4655            encoder: &mut fidl::encoding::Encoder<'_, D>,
4656            offset: usize,
4657            mut depth: fidl::encoding::Depth,
4658        ) -> fidl::Result<()> {
4659            encoder.debug_check_bounds::<BorderRoutingNat64State>(offset);
4660            // Vector header
4661            let max_ordinal: u64 = self.max_ordinal_present();
4662            encoder.write_num(max_ordinal, offset);
4663            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4664            // Calling encoder.out_of_line_offset(0) is not allowed.
4665            if max_ordinal == 0 {
4666                return Ok(());
4667            }
4668            depth.increment()?;
4669            let envelope_size = 8;
4670            let bytes_len = max_ordinal as usize * envelope_size;
4671            #[allow(unused_variables)]
4672            let offset = encoder.out_of_line_offset(bytes_len);
4673            let mut _prev_end_offset: usize = 0;
4674            if 1 > max_ordinal {
4675                return Ok(());
4676            }
4677
4678            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4679            // are envelope_size bytes.
4680            let cur_offset: usize = (1 - 1) * envelope_size;
4681
4682            // Zero reserved fields.
4683            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4684
4685            // Safety:
4686            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4687            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4688            //   envelope_size bytes, there is always sufficient room.
4689            fidl::encoding::encode_in_envelope_optional::<Nat64State, D>(
4690                self.prefix_manager_state
4691                    .as_ref()
4692                    .map(<Nat64State as fidl::encoding::ValueTypeMarker>::borrow),
4693                encoder,
4694                offset + cur_offset,
4695                depth,
4696            )?;
4697
4698            _prev_end_offset = cur_offset + envelope_size;
4699            if 2 > max_ordinal {
4700                return Ok(());
4701            }
4702
4703            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4704            // are envelope_size bytes.
4705            let cur_offset: usize = (2 - 1) * envelope_size;
4706
4707            // Zero reserved fields.
4708            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4709
4710            // Safety:
4711            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4712            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4713            //   envelope_size bytes, there is always sufficient room.
4714            fidl::encoding::encode_in_envelope_optional::<Nat64State, D>(
4715                self.translator_state
4716                    .as_ref()
4717                    .map(<Nat64State as fidl::encoding::ValueTypeMarker>::borrow),
4718                encoder,
4719                offset + cur_offset,
4720                depth,
4721            )?;
4722
4723            _prev_end_offset = cur_offset + envelope_size;
4724
4725            Ok(())
4726        }
4727    }
4728
4729    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4730        for BorderRoutingNat64State
4731    {
4732        #[inline(always)]
4733        fn new_empty() -> Self {
4734            Self::default()
4735        }
4736
4737        unsafe fn decode(
4738            &mut self,
4739            decoder: &mut fidl::encoding::Decoder<'_, D>,
4740            offset: usize,
4741            mut depth: fidl::encoding::Depth,
4742        ) -> fidl::Result<()> {
4743            decoder.debug_check_bounds::<Self>(offset);
4744            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4745                None => return Err(fidl::Error::NotNullable),
4746                Some(len) => len,
4747            };
4748            // Calling decoder.out_of_line_offset(0) is not allowed.
4749            if len == 0 {
4750                return Ok(());
4751            };
4752            depth.increment()?;
4753            let envelope_size = 8;
4754            let bytes_len = len * envelope_size;
4755            let offset = decoder.out_of_line_offset(bytes_len)?;
4756            // Decode the envelope for each type.
4757            let mut _next_ordinal_to_read = 0;
4758            let mut next_offset = offset;
4759            let end_offset = offset + bytes_len;
4760            _next_ordinal_to_read += 1;
4761            if next_offset >= end_offset {
4762                return Ok(());
4763            }
4764
4765            // Decode unknown envelopes for gaps in ordinals.
4766            while _next_ordinal_to_read < 1 {
4767                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4768                _next_ordinal_to_read += 1;
4769                next_offset += envelope_size;
4770            }
4771
4772            let next_out_of_line = decoder.next_out_of_line();
4773            let handles_before = decoder.remaining_handles();
4774            if let Some((inlined, num_bytes, num_handles)) =
4775                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4776            {
4777                let member_inline_size =
4778                    <Nat64State as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4779                if inlined != (member_inline_size <= 4) {
4780                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4781                }
4782                let inner_offset;
4783                let mut inner_depth = depth.clone();
4784                if inlined {
4785                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4786                    inner_offset = next_offset;
4787                } else {
4788                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4789                    inner_depth.increment()?;
4790                }
4791                let val_ref = self
4792                    .prefix_manager_state
4793                    .get_or_insert_with(|| fidl::new_empty!(Nat64State, D));
4794                fidl::decode!(Nat64State, D, val_ref, decoder, inner_offset, inner_depth)?;
4795                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4796                {
4797                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4798                }
4799                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4800                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4801                }
4802            }
4803
4804            next_offset += envelope_size;
4805            _next_ordinal_to_read += 1;
4806            if next_offset >= end_offset {
4807                return Ok(());
4808            }
4809
4810            // Decode unknown envelopes for gaps in ordinals.
4811            while _next_ordinal_to_read < 2 {
4812                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4813                _next_ordinal_to_read += 1;
4814                next_offset += envelope_size;
4815            }
4816
4817            let next_out_of_line = decoder.next_out_of_line();
4818            let handles_before = decoder.remaining_handles();
4819            if let Some((inlined, num_bytes, num_handles)) =
4820                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4821            {
4822                let member_inline_size =
4823                    <Nat64State as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4824                if inlined != (member_inline_size <= 4) {
4825                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4826                }
4827                let inner_offset;
4828                let mut inner_depth = depth.clone();
4829                if inlined {
4830                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4831                    inner_offset = next_offset;
4832                } else {
4833                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4834                    inner_depth.increment()?;
4835                }
4836                let val_ref =
4837                    self.translator_state.get_or_insert_with(|| fidl::new_empty!(Nat64State, D));
4838                fidl::decode!(Nat64State, D, val_ref, decoder, inner_offset, inner_depth)?;
4839                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4840                {
4841                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4842                }
4843                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4844                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4845                }
4846            }
4847
4848            next_offset += envelope_size;
4849
4850            // Decode the remaining unknown envelopes.
4851            while next_offset < end_offset {
4852                _next_ordinal_to_read += 1;
4853                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4854                next_offset += envelope_size;
4855            }
4856
4857            Ok(())
4858        }
4859    }
4860
4861    impl ChannelInfo {
4862        #[inline(always)]
4863        fn max_ordinal_present(&self) -> u64 {
4864            if let Some(_) = self.masked_by_regulatory_domain {
4865                return 6;
4866            }
4867            if let Some(_) = self.spectrum_bandwidth_hz {
4868                return 5;
4869            }
4870            if let Some(_) = self.spectrum_center_frequency_hz {
4871                return 4;
4872            }
4873            if let Some(_) = self.max_transmit_power_dbm {
4874                return 3;
4875            }
4876            if let Some(_) = self.id {
4877                return 2;
4878            }
4879            if let Some(_) = self.index {
4880                return 1;
4881            }
4882            0
4883        }
4884    }
4885
4886    impl fidl::encoding::ValueTypeMarker for ChannelInfo {
4887        type Borrowed<'a> = &'a Self;
4888        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4889            value
4890        }
4891    }
4892
4893    unsafe impl fidl::encoding::TypeMarker for ChannelInfo {
4894        type Owned = Self;
4895
4896        #[inline(always)]
4897        fn inline_align(_context: fidl::encoding::Context) -> usize {
4898            8
4899        }
4900
4901        #[inline(always)]
4902        fn inline_size(_context: fidl::encoding::Context) -> usize {
4903            16
4904        }
4905    }
4906
4907    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChannelInfo, D>
4908        for &ChannelInfo
4909    {
4910        unsafe fn encode(
4911            self,
4912            encoder: &mut fidl::encoding::Encoder<'_, D>,
4913            offset: usize,
4914            mut depth: fidl::encoding::Depth,
4915        ) -> fidl::Result<()> {
4916            encoder.debug_check_bounds::<ChannelInfo>(offset);
4917            // Vector header
4918            let max_ordinal: u64 = self.max_ordinal_present();
4919            encoder.write_num(max_ordinal, offset);
4920            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4921            // Calling encoder.out_of_line_offset(0) is not allowed.
4922            if max_ordinal == 0 {
4923                return Ok(());
4924            }
4925            depth.increment()?;
4926            let envelope_size = 8;
4927            let bytes_len = max_ordinal as usize * envelope_size;
4928            #[allow(unused_variables)]
4929            let offset = encoder.out_of_line_offset(bytes_len);
4930            let mut _prev_end_offset: usize = 0;
4931            if 1 > max_ordinal {
4932                return Ok(());
4933            }
4934
4935            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4936            // are envelope_size bytes.
4937            let cur_offset: usize = (1 - 1) * envelope_size;
4938
4939            // Zero reserved fields.
4940            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4941
4942            // Safety:
4943            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4944            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4945            //   envelope_size bytes, there is always sufficient room.
4946            fidl::encoding::encode_in_envelope_optional::<u16, D>(
4947                self.index.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
4948                encoder,
4949                offset + cur_offset,
4950                depth,
4951            )?;
4952
4953            _prev_end_offset = cur_offset + envelope_size;
4954            if 2 > max_ordinal {
4955                return Ok(());
4956            }
4957
4958            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4959            // are envelope_size bytes.
4960            let cur_offset: usize = (2 - 1) * envelope_size;
4961
4962            // Zero reserved fields.
4963            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4964
4965            // Safety:
4966            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4967            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4968            //   envelope_size bytes, there is always sufficient room.
4969            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<16>, D>(
4970                self.id.as_ref().map(
4971                    <fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow,
4972                ),
4973                encoder,
4974                offset + cur_offset,
4975                depth,
4976            )?;
4977
4978            _prev_end_offset = cur_offset + envelope_size;
4979            if 3 > max_ordinal {
4980                return Ok(());
4981            }
4982
4983            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4984            // are envelope_size bytes.
4985            let cur_offset: usize = (3 - 1) * envelope_size;
4986
4987            // Zero reserved fields.
4988            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4989
4990            // Safety:
4991            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4992            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4993            //   envelope_size bytes, there is always sufficient room.
4994            fidl::encoding::encode_in_envelope_optional::<i8, D>(
4995                self.max_transmit_power_dbm
4996                    .as_ref()
4997                    .map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
4998                encoder,
4999                offset + cur_offset,
5000                depth,
5001            )?;
5002
5003            _prev_end_offset = cur_offset + envelope_size;
5004            if 4 > max_ordinal {
5005                return Ok(());
5006            }
5007
5008            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5009            // are envelope_size bytes.
5010            let cur_offset: usize = (4 - 1) * envelope_size;
5011
5012            // Zero reserved fields.
5013            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5014
5015            // Safety:
5016            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5017            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5018            //   envelope_size bytes, there is always sufficient room.
5019            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5020                self.spectrum_center_frequency_hz
5021                    .as_ref()
5022                    .map(<u64 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 5 > 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 = (5 - 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::<u64, D>(
5045                self.spectrum_bandwidth_hz
5046                    .as_ref()
5047                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5048                encoder,
5049                offset + cur_offset,
5050                depth,
5051            )?;
5052
5053            _prev_end_offset = cur_offset + envelope_size;
5054            if 6 > max_ordinal {
5055                return Ok(());
5056            }
5057
5058            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5059            // are envelope_size bytes.
5060            let cur_offset: usize = (6 - 1) * envelope_size;
5061
5062            // Zero reserved fields.
5063            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5064
5065            // Safety:
5066            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5067            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5068            //   envelope_size bytes, there is always sufficient room.
5069            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5070                self.masked_by_regulatory_domain
5071                    .as_ref()
5072                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5073                encoder,
5074                offset + cur_offset,
5075                depth,
5076            )?;
5077
5078            _prev_end_offset = cur_offset + envelope_size;
5079
5080            Ok(())
5081        }
5082    }
5083
5084    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChannelInfo {
5085        #[inline(always)]
5086        fn new_empty() -> Self {
5087            Self::default()
5088        }
5089
5090        unsafe fn decode(
5091            &mut self,
5092            decoder: &mut fidl::encoding::Decoder<'_, D>,
5093            offset: usize,
5094            mut depth: fidl::encoding::Depth,
5095        ) -> fidl::Result<()> {
5096            decoder.debug_check_bounds::<Self>(offset);
5097            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5098                None => return Err(fidl::Error::NotNullable),
5099                Some(len) => len,
5100            };
5101            // Calling decoder.out_of_line_offset(0) is not allowed.
5102            if len == 0 {
5103                return Ok(());
5104            };
5105            depth.increment()?;
5106            let envelope_size = 8;
5107            let bytes_len = len * envelope_size;
5108            let offset = decoder.out_of_line_offset(bytes_len)?;
5109            // Decode the envelope for each type.
5110            let mut _next_ordinal_to_read = 0;
5111            let mut next_offset = offset;
5112            let end_offset = offset + bytes_len;
5113            _next_ordinal_to_read += 1;
5114            if next_offset >= end_offset {
5115                return Ok(());
5116            }
5117
5118            // Decode unknown envelopes for gaps in ordinals.
5119            while _next_ordinal_to_read < 1 {
5120                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5121                _next_ordinal_to_read += 1;
5122                next_offset += envelope_size;
5123            }
5124
5125            let next_out_of_line = decoder.next_out_of_line();
5126            let handles_before = decoder.remaining_handles();
5127            if let Some((inlined, num_bytes, num_handles)) =
5128                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5129            {
5130                let member_inline_size =
5131                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5132                if inlined != (member_inline_size <= 4) {
5133                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5134                }
5135                let inner_offset;
5136                let mut inner_depth = depth.clone();
5137                if inlined {
5138                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5139                    inner_offset = next_offset;
5140                } else {
5141                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5142                    inner_depth.increment()?;
5143                }
5144                let val_ref = self.index.get_or_insert_with(|| fidl::new_empty!(u16, D));
5145                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5146                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5147                {
5148                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5149                }
5150                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5151                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5152                }
5153            }
5154
5155            next_offset += envelope_size;
5156            _next_ordinal_to_read += 1;
5157            if next_offset >= end_offset {
5158                return Ok(());
5159            }
5160
5161            // Decode unknown envelopes for gaps in ordinals.
5162            while _next_ordinal_to_read < 2 {
5163                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5164                _next_ordinal_to_read += 1;
5165                next_offset += envelope_size;
5166            }
5167
5168            let next_out_of_line = decoder.next_out_of_line();
5169            let handles_before = decoder.remaining_handles();
5170            if let Some((inlined, num_bytes, num_handles)) =
5171                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5172            {
5173                let member_inline_size =
5174                    <fidl::encoding::BoundedString<16> as fidl::encoding::TypeMarker>::inline_size(
5175                        decoder.context,
5176                    );
5177                if inlined != (member_inline_size <= 4) {
5178                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5179                }
5180                let inner_offset;
5181                let mut inner_depth = depth.clone();
5182                if inlined {
5183                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5184                    inner_offset = next_offset;
5185                } else {
5186                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5187                    inner_depth.increment()?;
5188                }
5189                let val_ref = self
5190                    .id
5191                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<16>, D));
5192                fidl::decode!(
5193                    fidl::encoding::BoundedString<16>,
5194                    D,
5195                    val_ref,
5196                    decoder,
5197                    inner_offset,
5198                    inner_depth
5199                )?;
5200                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5201                {
5202                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5203                }
5204                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5205                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5206                }
5207            }
5208
5209            next_offset += envelope_size;
5210            _next_ordinal_to_read += 1;
5211            if next_offset >= end_offset {
5212                return Ok(());
5213            }
5214
5215            // Decode unknown envelopes for gaps in ordinals.
5216            while _next_ordinal_to_read < 3 {
5217                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5218                _next_ordinal_to_read += 1;
5219                next_offset += envelope_size;
5220            }
5221
5222            let next_out_of_line = decoder.next_out_of_line();
5223            let handles_before = decoder.remaining_handles();
5224            if let Some((inlined, num_bytes, num_handles)) =
5225                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5226            {
5227                let member_inline_size =
5228                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5229                if inlined != (member_inline_size <= 4) {
5230                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5231                }
5232                let inner_offset;
5233                let mut inner_depth = depth.clone();
5234                if inlined {
5235                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5236                    inner_offset = next_offset;
5237                } else {
5238                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5239                    inner_depth.increment()?;
5240                }
5241                let val_ref =
5242                    self.max_transmit_power_dbm.get_or_insert_with(|| fidl::new_empty!(i8, D));
5243                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
5244                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5245                {
5246                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5247                }
5248                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5249                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5250                }
5251            }
5252
5253            next_offset += envelope_size;
5254            _next_ordinal_to_read += 1;
5255            if next_offset >= end_offset {
5256                return Ok(());
5257            }
5258
5259            // Decode unknown envelopes for gaps in ordinals.
5260            while _next_ordinal_to_read < 4 {
5261                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5262                _next_ordinal_to_read += 1;
5263                next_offset += envelope_size;
5264            }
5265
5266            let next_out_of_line = decoder.next_out_of_line();
5267            let handles_before = decoder.remaining_handles();
5268            if let Some((inlined, num_bytes, num_handles)) =
5269                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5270            {
5271                let member_inline_size =
5272                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5273                if inlined != (member_inline_size <= 4) {
5274                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5275                }
5276                let inner_offset;
5277                let mut inner_depth = depth.clone();
5278                if inlined {
5279                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5280                    inner_offset = next_offset;
5281                } else {
5282                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5283                    inner_depth.increment()?;
5284                }
5285                let val_ref = self
5286                    .spectrum_center_frequency_hz
5287                    .get_or_insert_with(|| fidl::new_empty!(u64, D));
5288                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5289                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5290                {
5291                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5292                }
5293                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5294                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5295                }
5296            }
5297
5298            next_offset += envelope_size;
5299            _next_ordinal_to_read += 1;
5300            if next_offset >= end_offset {
5301                return Ok(());
5302            }
5303
5304            // Decode unknown envelopes for gaps in ordinals.
5305            while _next_ordinal_to_read < 5 {
5306                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5307                _next_ordinal_to_read += 1;
5308                next_offset += envelope_size;
5309            }
5310
5311            let next_out_of_line = decoder.next_out_of_line();
5312            let handles_before = decoder.remaining_handles();
5313            if let Some((inlined, num_bytes, num_handles)) =
5314                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5315            {
5316                let member_inline_size =
5317                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5318                if inlined != (member_inline_size <= 4) {
5319                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5320                }
5321                let inner_offset;
5322                let mut inner_depth = depth.clone();
5323                if inlined {
5324                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5325                    inner_offset = next_offset;
5326                } else {
5327                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5328                    inner_depth.increment()?;
5329                }
5330                let val_ref =
5331                    self.spectrum_bandwidth_hz.get_or_insert_with(|| fidl::new_empty!(u64, D));
5332                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5333                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5334                {
5335                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5336                }
5337                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5338                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5339                }
5340            }
5341
5342            next_offset += envelope_size;
5343            _next_ordinal_to_read += 1;
5344            if next_offset >= end_offset {
5345                return Ok(());
5346            }
5347
5348            // Decode unknown envelopes for gaps in ordinals.
5349            while _next_ordinal_to_read < 6 {
5350                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5351                _next_ordinal_to_read += 1;
5352                next_offset += envelope_size;
5353            }
5354
5355            let next_out_of_line = decoder.next_out_of_line();
5356            let handles_before = decoder.remaining_handles();
5357            if let Some((inlined, num_bytes, num_handles)) =
5358                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5359            {
5360                let member_inline_size =
5361                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5362                if inlined != (member_inline_size <= 4) {
5363                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5364                }
5365                let inner_offset;
5366                let mut inner_depth = depth.clone();
5367                if inlined {
5368                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5369                    inner_offset = next_offset;
5370                } else {
5371                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5372                    inner_depth.increment()?;
5373                }
5374                let val_ref = self
5375                    .masked_by_regulatory_domain
5376                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
5377                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5378                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5379                {
5380                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5381                }
5382                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5383                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5384                }
5385            }
5386
5387            next_offset += envelope_size;
5388
5389            // Decode the remaining unknown envelopes.
5390            while next_offset < end_offset {
5391                _next_ordinal_to_read += 1;
5392                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5393                next_offset += envelope_size;
5394            }
5395
5396            Ok(())
5397        }
5398    }
5399
5400    impl Dhcp6PdInfo {
5401        #[inline(always)]
5402        fn max_ordinal_present(&self) -> u64 {
5403            if let Some(_) = self.hashed_pd_prefix {
5404                return 3;
5405            }
5406            if let Some(_) = self.pd_processed_ra_info {
5407                return 2;
5408            }
5409            if let Some(_) = self.dhcp6pd_state {
5410                return 1;
5411            }
5412            0
5413        }
5414    }
5415
5416    impl fidl::encoding::ValueTypeMarker for Dhcp6PdInfo {
5417        type Borrowed<'a> = &'a Self;
5418        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5419            value
5420        }
5421    }
5422
5423    unsafe impl fidl::encoding::TypeMarker for Dhcp6PdInfo {
5424        type Owned = Self;
5425
5426        #[inline(always)]
5427        fn inline_align(_context: fidl::encoding::Context) -> usize {
5428            8
5429        }
5430
5431        #[inline(always)]
5432        fn inline_size(_context: fidl::encoding::Context) -> usize {
5433            16
5434        }
5435    }
5436
5437    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Dhcp6PdInfo, D>
5438        for &Dhcp6PdInfo
5439    {
5440        unsafe fn encode(
5441            self,
5442            encoder: &mut fidl::encoding::Encoder<'_, D>,
5443            offset: usize,
5444            mut depth: fidl::encoding::Depth,
5445        ) -> fidl::Result<()> {
5446            encoder.debug_check_bounds::<Dhcp6PdInfo>(offset);
5447            // Vector header
5448            let max_ordinal: u64 = self.max_ordinal_present();
5449            encoder.write_num(max_ordinal, offset);
5450            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5451            // Calling encoder.out_of_line_offset(0) is not allowed.
5452            if max_ordinal == 0 {
5453                return Ok(());
5454            }
5455            depth.increment()?;
5456            let envelope_size = 8;
5457            let bytes_len = max_ordinal as usize * envelope_size;
5458            #[allow(unused_variables)]
5459            let offset = encoder.out_of_line_offset(bytes_len);
5460            let mut _prev_end_offset: usize = 0;
5461            if 1 > max_ordinal {
5462                return Ok(());
5463            }
5464
5465            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5466            // are envelope_size bytes.
5467            let cur_offset: usize = (1 - 1) * envelope_size;
5468
5469            // Zero reserved fields.
5470            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5471
5472            // Safety:
5473            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5474            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5475            //   envelope_size bytes, there is always sufficient room.
5476            fidl::encoding::encode_in_envelope_optional::<Dhcp6PdState, D>(
5477                self.dhcp6pd_state
5478                    .as_ref()
5479                    .map(<Dhcp6PdState as fidl::encoding::ValueTypeMarker>::borrow),
5480                encoder,
5481                offset + cur_offset,
5482                depth,
5483            )?;
5484
5485            _prev_end_offset = cur_offset + envelope_size;
5486            if 2 > max_ordinal {
5487                return Ok(());
5488            }
5489
5490            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5491            // are envelope_size bytes.
5492            let cur_offset: usize = (2 - 1) * envelope_size;
5493
5494            // Zero reserved fields.
5495            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5496
5497            // Safety:
5498            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5499            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5500            //   envelope_size bytes, there is always sufficient room.
5501            fidl::encoding::encode_in_envelope_optional::<PdProcessedRaInfo, D>(
5502                self.pd_processed_ra_info
5503                    .as_ref()
5504                    .map(<PdProcessedRaInfo as fidl::encoding::ValueTypeMarker>::borrow),
5505                encoder,
5506                offset + cur_offset,
5507                depth,
5508            )?;
5509
5510            _prev_end_offset = cur_offset + envelope_size;
5511            if 3 > max_ordinal {
5512                return Ok(());
5513            }
5514
5515            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5516            // are envelope_size bytes.
5517            let cur_offset: usize = (3 - 1) * envelope_size;
5518
5519            // Zero reserved fields.
5520            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5521
5522            // Safety:
5523            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5524            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5525            //   envelope_size bytes, there is always sufficient room.
5526            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
5527                self.hashed_pd_prefix.as_ref().map(
5528                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
5529                ),
5530                encoder,
5531                offset + cur_offset,
5532                depth,
5533            )?;
5534
5535            _prev_end_offset = cur_offset + envelope_size;
5536
5537            Ok(())
5538        }
5539    }
5540
5541    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Dhcp6PdInfo {
5542        #[inline(always)]
5543        fn new_empty() -> Self {
5544            Self::default()
5545        }
5546
5547        unsafe fn decode(
5548            &mut self,
5549            decoder: &mut fidl::encoding::Decoder<'_, D>,
5550            offset: usize,
5551            mut depth: fidl::encoding::Depth,
5552        ) -> fidl::Result<()> {
5553            decoder.debug_check_bounds::<Self>(offset);
5554            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5555                None => return Err(fidl::Error::NotNullable),
5556                Some(len) => len,
5557            };
5558            // Calling decoder.out_of_line_offset(0) is not allowed.
5559            if len == 0 {
5560                return Ok(());
5561            };
5562            depth.increment()?;
5563            let envelope_size = 8;
5564            let bytes_len = len * envelope_size;
5565            let offset = decoder.out_of_line_offset(bytes_len)?;
5566            // Decode the envelope for each type.
5567            let mut _next_ordinal_to_read = 0;
5568            let mut next_offset = offset;
5569            let end_offset = offset + bytes_len;
5570            _next_ordinal_to_read += 1;
5571            if next_offset >= end_offset {
5572                return Ok(());
5573            }
5574
5575            // Decode unknown envelopes for gaps in ordinals.
5576            while _next_ordinal_to_read < 1 {
5577                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5578                _next_ordinal_to_read += 1;
5579                next_offset += envelope_size;
5580            }
5581
5582            let next_out_of_line = decoder.next_out_of_line();
5583            let handles_before = decoder.remaining_handles();
5584            if let Some((inlined, num_bytes, num_handles)) =
5585                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5586            {
5587                let member_inline_size =
5588                    <Dhcp6PdState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5589                if inlined != (member_inline_size <= 4) {
5590                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5591                }
5592                let inner_offset;
5593                let mut inner_depth = depth.clone();
5594                if inlined {
5595                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5596                    inner_offset = next_offset;
5597                } else {
5598                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5599                    inner_depth.increment()?;
5600                }
5601                let val_ref =
5602                    self.dhcp6pd_state.get_or_insert_with(|| fidl::new_empty!(Dhcp6PdState, D));
5603                fidl::decode!(Dhcp6PdState, D, val_ref, decoder, inner_offset, inner_depth)?;
5604                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5605                {
5606                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5607                }
5608                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5609                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5610                }
5611            }
5612
5613            next_offset += envelope_size;
5614            _next_ordinal_to_read += 1;
5615            if next_offset >= end_offset {
5616                return Ok(());
5617            }
5618
5619            // Decode unknown envelopes for gaps in ordinals.
5620            while _next_ordinal_to_read < 2 {
5621                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5622                _next_ordinal_to_read += 1;
5623                next_offset += envelope_size;
5624            }
5625
5626            let next_out_of_line = decoder.next_out_of_line();
5627            let handles_before = decoder.remaining_handles();
5628            if let Some((inlined, num_bytes, num_handles)) =
5629                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5630            {
5631                let member_inline_size =
5632                    <PdProcessedRaInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5633                if inlined != (member_inline_size <= 4) {
5634                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5635                }
5636                let inner_offset;
5637                let mut inner_depth = depth.clone();
5638                if inlined {
5639                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5640                    inner_offset = next_offset;
5641                } else {
5642                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5643                    inner_depth.increment()?;
5644                }
5645                let val_ref = self
5646                    .pd_processed_ra_info
5647                    .get_or_insert_with(|| fidl::new_empty!(PdProcessedRaInfo, D));
5648                fidl::decode!(PdProcessedRaInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
5649                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5650                {
5651                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5652                }
5653                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5654                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5655                }
5656            }
5657
5658            next_offset += envelope_size;
5659            _next_ordinal_to_read += 1;
5660            if next_offset >= end_offset {
5661                return Ok(());
5662            }
5663
5664            // Decode unknown envelopes for gaps in ordinals.
5665            while _next_ordinal_to_read < 3 {
5666                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5667                _next_ordinal_to_read += 1;
5668                next_offset += envelope_size;
5669            }
5670
5671            let next_out_of_line = decoder.next_out_of_line();
5672            let handles_before = decoder.remaining_handles();
5673            if let Some((inlined, num_bytes, num_handles)) =
5674                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5675            {
5676                let member_inline_size =
5677                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
5678                        decoder.context,
5679                    );
5680                if inlined != (member_inline_size <= 4) {
5681                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5682                }
5683                let inner_offset;
5684                let mut inner_depth = depth.clone();
5685                if inlined {
5686                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5687                    inner_offset = next_offset;
5688                } else {
5689                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5690                    inner_depth.increment()?;
5691                }
5692                let val_ref = self
5693                    .hashed_pd_prefix
5694                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
5695                fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
5696                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5697                {
5698                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5699                }
5700                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5701                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5702                }
5703            }
5704
5705            next_offset += envelope_size;
5706
5707            // Decode the remaining unknown envelopes.
5708            while next_offset < end_offset {
5709                _next_ordinal_to_read += 1;
5710                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5711                next_offset += envelope_size;
5712            }
5713
5714            Ok(())
5715        }
5716    }
5717
5718    impl DnssdCounters {
5719        #[inline(always)]
5720        fn max_ordinal_present(&self) -> u64 {
5721            if let Some(_) = self.upstream_dns_counters {
5722                return 8;
5723            }
5724            if let Some(_) = self.resolved_by_srp {
5725                return 7;
5726            }
5727            if let Some(_) = self.other_response {
5728                return 6;
5729            }
5730            if let Some(_) = self.not_implemented_response {
5731                return 5;
5732            }
5733            if let Some(_) = self.name_error_response {
5734                return 4;
5735            }
5736            if let Some(_) = self.format_error_response {
5737                return 3;
5738            }
5739            if let Some(_) = self.server_failure_response {
5740                return 2;
5741            }
5742            if let Some(_) = self.success_response {
5743                return 1;
5744            }
5745            0
5746        }
5747    }
5748
5749    impl fidl::encoding::ValueTypeMarker for DnssdCounters {
5750        type Borrowed<'a> = &'a Self;
5751        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5752            value
5753        }
5754    }
5755
5756    unsafe impl fidl::encoding::TypeMarker for DnssdCounters {
5757        type Owned = Self;
5758
5759        #[inline(always)]
5760        fn inline_align(_context: fidl::encoding::Context) -> usize {
5761            8
5762        }
5763
5764        #[inline(always)]
5765        fn inline_size(_context: fidl::encoding::Context) -> usize {
5766            16
5767        }
5768    }
5769
5770    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DnssdCounters, D>
5771        for &DnssdCounters
5772    {
5773        unsafe fn encode(
5774            self,
5775            encoder: &mut fidl::encoding::Encoder<'_, D>,
5776            offset: usize,
5777            mut depth: fidl::encoding::Depth,
5778        ) -> fidl::Result<()> {
5779            encoder.debug_check_bounds::<DnssdCounters>(offset);
5780            // Vector header
5781            let max_ordinal: u64 = self.max_ordinal_present();
5782            encoder.write_num(max_ordinal, offset);
5783            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5784            // Calling encoder.out_of_line_offset(0) is not allowed.
5785            if max_ordinal == 0 {
5786                return Ok(());
5787            }
5788            depth.increment()?;
5789            let envelope_size = 8;
5790            let bytes_len = max_ordinal as usize * envelope_size;
5791            #[allow(unused_variables)]
5792            let offset = encoder.out_of_line_offset(bytes_len);
5793            let mut _prev_end_offset: usize = 0;
5794            if 1 > max_ordinal {
5795                return Ok(());
5796            }
5797
5798            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5799            // are envelope_size bytes.
5800            let cur_offset: usize = (1 - 1) * envelope_size;
5801
5802            // Zero reserved fields.
5803            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5804
5805            // Safety:
5806            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5807            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5808            //   envelope_size bytes, there is always sufficient room.
5809            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5810                self.success_response
5811                    .as_ref()
5812                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5813                encoder,
5814                offset + cur_offset,
5815                depth,
5816            )?;
5817
5818            _prev_end_offset = cur_offset + envelope_size;
5819            if 2 > max_ordinal {
5820                return Ok(());
5821            }
5822
5823            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5824            // are envelope_size bytes.
5825            let cur_offset: usize = (2 - 1) * envelope_size;
5826
5827            // Zero reserved fields.
5828            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5829
5830            // Safety:
5831            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5832            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5833            //   envelope_size bytes, there is always sufficient room.
5834            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5835                self.server_failure_response
5836                    .as_ref()
5837                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5838                encoder,
5839                offset + cur_offset,
5840                depth,
5841            )?;
5842
5843            _prev_end_offset = cur_offset + envelope_size;
5844            if 3 > max_ordinal {
5845                return Ok(());
5846            }
5847
5848            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5849            // are envelope_size bytes.
5850            let cur_offset: usize = (3 - 1) * envelope_size;
5851
5852            // Zero reserved fields.
5853            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5854
5855            // Safety:
5856            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5857            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5858            //   envelope_size bytes, there is always sufficient room.
5859            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5860                self.format_error_response
5861                    .as_ref()
5862                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5863                encoder,
5864                offset + cur_offset,
5865                depth,
5866            )?;
5867
5868            _prev_end_offset = cur_offset + envelope_size;
5869            if 4 > max_ordinal {
5870                return Ok(());
5871            }
5872
5873            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5874            // are envelope_size bytes.
5875            let cur_offset: usize = (4 - 1) * envelope_size;
5876
5877            // Zero reserved fields.
5878            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5879
5880            // Safety:
5881            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5882            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5883            //   envelope_size bytes, there is always sufficient room.
5884            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5885                self.name_error_response
5886                    .as_ref()
5887                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5888                encoder,
5889                offset + cur_offset,
5890                depth,
5891            )?;
5892
5893            _prev_end_offset = cur_offset + envelope_size;
5894            if 5 > max_ordinal {
5895                return Ok(());
5896            }
5897
5898            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5899            // are envelope_size bytes.
5900            let cur_offset: usize = (5 - 1) * envelope_size;
5901
5902            // Zero reserved fields.
5903            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5904
5905            // Safety:
5906            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5907            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5908            //   envelope_size bytes, there is always sufficient room.
5909            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5910                self.not_implemented_response
5911                    .as_ref()
5912                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5913                encoder,
5914                offset + cur_offset,
5915                depth,
5916            )?;
5917
5918            _prev_end_offset = cur_offset + envelope_size;
5919            if 6 > max_ordinal {
5920                return Ok(());
5921            }
5922
5923            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5924            // are envelope_size bytes.
5925            let cur_offset: usize = (6 - 1) * envelope_size;
5926
5927            // Zero reserved fields.
5928            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5929
5930            // Safety:
5931            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5932            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5933            //   envelope_size bytes, there is always sufficient room.
5934            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5935                self.other_response.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5936                encoder,
5937                offset + cur_offset,
5938                depth,
5939            )?;
5940
5941            _prev_end_offset = cur_offset + envelope_size;
5942            if 7 > max_ordinal {
5943                return Ok(());
5944            }
5945
5946            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5947            // are envelope_size bytes.
5948            let cur_offset: usize = (7 - 1) * envelope_size;
5949
5950            // Zero reserved fields.
5951            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5952
5953            // Safety:
5954            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5955            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5956            //   envelope_size bytes, there is always sufficient room.
5957            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5958                self.resolved_by_srp.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5959                encoder,
5960                offset + cur_offset,
5961                depth,
5962            )?;
5963
5964            _prev_end_offset = cur_offset + envelope_size;
5965            if 8 > max_ordinal {
5966                return Ok(());
5967            }
5968
5969            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5970            // are envelope_size bytes.
5971            let cur_offset: usize = (8 - 1) * envelope_size;
5972
5973            // Zero reserved fields.
5974            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5975
5976            // Safety:
5977            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5978            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5979            //   envelope_size bytes, there is always sufficient room.
5980            fidl::encoding::encode_in_envelope_optional::<UpstreamDnsCounters, D>(
5981                self.upstream_dns_counters
5982                    .as_ref()
5983                    .map(<UpstreamDnsCounters as fidl::encoding::ValueTypeMarker>::borrow),
5984                encoder,
5985                offset + cur_offset,
5986                depth,
5987            )?;
5988
5989            _prev_end_offset = cur_offset + envelope_size;
5990
5991            Ok(())
5992        }
5993    }
5994
5995    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DnssdCounters {
5996        #[inline(always)]
5997        fn new_empty() -> Self {
5998            Self::default()
5999        }
6000
6001        unsafe fn decode(
6002            &mut self,
6003            decoder: &mut fidl::encoding::Decoder<'_, D>,
6004            offset: usize,
6005            mut depth: fidl::encoding::Depth,
6006        ) -> fidl::Result<()> {
6007            decoder.debug_check_bounds::<Self>(offset);
6008            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6009                None => return Err(fidl::Error::NotNullable),
6010                Some(len) => len,
6011            };
6012            // Calling decoder.out_of_line_offset(0) is not allowed.
6013            if len == 0 {
6014                return Ok(());
6015            };
6016            depth.increment()?;
6017            let envelope_size = 8;
6018            let bytes_len = len * envelope_size;
6019            let offset = decoder.out_of_line_offset(bytes_len)?;
6020            // Decode the envelope for each type.
6021            let mut _next_ordinal_to_read = 0;
6022            let mut next_offset = offset;
6023            let end_offset = offset + bytes_len;
6024            _next_ordinal_to_read += 1;
6025            if next_offset >= end_offset {
6026                return Ok(());
6027            }
6028
6029            // Decode unknown envelopes for gaps in ordinals.
6030            while _next_ordinal_to_read < 1 {
6031                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6032                _next_ordinal_to_read += 1;
6033                next_offset += envelope_size;
6034            }
6035
6036            let next_out_of_line = decoder.next_out_of_line();
6037            let handles_before = decoder.remaining_handles();
6038            if let Some((inlined, num_bytes, num_handles)) =
6039                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6040            {
6041                let member_inline_size =
6042                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6043                if inlined != (member_inline_size <= 4) {
6044                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6045                }
6046                let inner_offset;
6047                let mut inner_depth = depth.clone();
6048                if inlined {
6049                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6050                    inner_offset = next_offset;
6051                } else {
6052                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6053                    inner_depth.increment()?;
6054                }
6055                let val_ref = self.success_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6056                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6057                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6058                {
6059                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6060                }
6061                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6062                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6063                }
6064            }
6065
6066            next_offset += envelope_size;
6067            _next_ordinal_to_read += 1;
6068            if next_offset >= end_offset {
6069                return Ok(());
6070            }
6071
6072            // Decode unknown envelopes for gaps in ordinals.
6073            while _next_ordinal_to_read < 2 {
6074                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6075                _next_ordinal_to_read += 1;
6076                next_offset += envelope_size;
6077            }
6078
6079            let next_out_of_line = decoder.next_out_of_line();
6080            let handles_before = decoder.remaining_handles();
6081            if let Some((inlined, num_bytes, num_handles)) =
6082                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6083            {
6084                let member_inline_size =
6085                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6086                if inlined != (member_inline_size <= 4) {
6087                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6088                }
6089                let inner_offset;
6090                let mut inner_depth = depth.clone();
6091                if inlined {
6092                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6093                    inner_offset = next_offset;
6094                } else {
6095                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6096                    inner_depth.increment()?;
6097                }
6098                let val_ref =
6099                    self.server_failure_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6100                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6101                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6102                {
6103                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6104                }
6105                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6106                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6107                }
6108            }
6109
6110            next_offset += envelope_size;
6111            _next_ordinal_to_read += 1;
6112            if next_offset >= end_offset {
6113                return Ok(());
6114            }
6115
6116            // Decode unknown envelopes for gaps in ordinals.
6117            while _next_ordinal_to_read < 3 {
6118                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6119                _next_ordinal_to_read += 1;
6120                next_offset += envelope_size;
6121            }
6122
6123            let next_out_of_line = decoder.next_out_of_line();
6124            let handles_before = decoder.remaining_handles();
6125            if let Some((inlined, num_bytes, num_handles)) =
6126                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6127            {
6128                let member_inline_size =
6129                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6130                if inlined != (member_inline_size <= 4) {
6131                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6132                }
6133                let inner_offset;
6134                let mut inner_depth = depth.clone();
6135                if inlined {
6136                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6137                    inner_offset = next_offset;
6138                } else {
6139                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6140                    inner_depth.increment()?;
6141                }
6142                let val_ref =
6143                    self.format_error_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6144                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6145                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6146                {
6147                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6148                }
6149                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6150                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6151                }
6152            }
6153
6154            next_offset += envelope_size;
6155            _next_ordinal_to_read += 1;
6156            if next_offset >= end_offset {
6157                return Ok(());
6158            }
6159
6160            // Decode unknown envelopes for gaps in ordinals.
6161            while _next_ordinal_to_read < 4 {
6162                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6163                _next_ordinal_to_read += 1;
6164                next_offset += envelope_size;
6165            }
6166
6167            let next_out_of_line = decoder.next_out_of_line();
6168            let handles_before = decoder.remaining_handles();
6169            if let Some((inlined, num_bytes, num_handles)) =
6170                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6171            {
6172                let member_inline_size =
6173                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6174                if inlined != (member_inline_size <= 4) {
6175                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6176                }
6177                let inner_offset;
6178                let mut inner_depth = depth.clone();
6179                if inlined {
6180                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6181                    inner_offset = next_offset;
6182                } else {
6183                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6184                    inner_depth.increment()?;
6185                }
6186                let val_ref =
6187                    self.name_error_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6188                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6189                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6190                {
6191                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6192                }
6193                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6194                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6195                }
6196            }
6197
6198            next_offset += envelope_size;
6199            _next_ordinal_to_read += 1;
6200            if next_offset >= end_offset {
6201                return Ok(());
6202            }
6203
6204            // Decode unknown envelopes for gaps in ordinals.
6205            while _next_ordinal_to_read < 5 {
6206                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6207                _next_ordinal_to_read += 1;
6208                next_offset += envelope_size;
6209            }
6210
6211            let next_out_of_line = decoder.next_out_of_line();
6212            let handles_before = decoder.remaining_handles();
6213            if let Some((inlined, num_bytes, num_handles)) =
6214                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6215            {
6216                let member_inline_size =
6217                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6218                if inlined != (member_inline_size <= 4) {
6219                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6220                }
6221                let inner_offset;
6222                let mut inner_depth = depth.clone();
6223                if inlined {
6224                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6225                    inner_offset = next_offset;
6226                } else {
6227                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6228                    inner_depth.increment()?;
6229                }
6230                let val_ref =
6231                    self.not_implemented_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6232                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6233                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6234                {
6235                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6236                }
6237                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6238                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6239                }
6240            }
6241
6242            next_offset += envelope_size;
6243            _next_ordinal_to_read += 1;
6244            if next_offset >= end_offset {
6245                return Ok(());
6246            }
6247
6248            // Decode unknown envelopes for gaps in ordinals.
6249            while _next_ordinal_to_read < 6 {
6250                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6251                _next_ordinal_to_read += 1;
6252                next_offset += envelope_size;
6253            }
6254
6255            let next_out_of_line = decoder.next_out_of_line();
6256            let handles_before = decoder.remaining_handles();
6257            if let Some((inlined, num_bytes, num_handles)) =
6258                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6259            {
6260                let member_inline_size =
6261                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6262                if inlined != (member_inline_size <= 4) {
6263                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6264                }
6265                let inner_offset;
6266                let mut inner_depth = depth.clone();
6267                if inlined {
6268                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6269                    inner_offset = next_offset;
6270                } else {
6271                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6272                    inner_depth.increment()?;
6273                }
6274                let val_ref = self.other_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6275                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6276                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6277                {
6278                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6279                }
6280                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6281                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6282                }
6283            }
6284
6285            next_offset += envelope_size;
6286            _next_ordinal_to_read += 1;
6287            if next_offset >= end_offset {
6288                return Ok(());
6289            }
6290
6291            // Decode unknown envelopes for gaps in ordinals.
6292            while _next_ordinal_to_read < 7 {
6293                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6294                _next_ordinal_to_read += 1;
6295                next_offset += envelope_size;
6296            }
6297
6298            let next_out_of_line = decoder.next_out_of_line();
6299            let handles_before = decoder.remaining_handles();
6300            if let Some((inlined, num_bytes, num_handles)) =
6301                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6302            {
6303                let member_inline_size =
6304                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6305                if inlined != (member_inline_size <= 4) {
6306                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6307                }
6308                let inner_offset;
6309                let mut inner_depth = depth.clone();
6310                if inlined {
6311                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6312                    inner_offset = next_offset;
6313                } else {
6314                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6315                    inner_depth.increment()?;
6316                }
6317                let val_ref = self.resolved_by_srp.get_or_insert_with(|| fidl::new_empty!(u32, D));
6318                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6319                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6320                {
6321                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6322                }
6323                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6324                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6325                }
6326            }
6327
6328            next_offset += envelope_size;
6329            _next_ordinal_to_read += 1;
6330            if next_offset >= end_offset {
6331                return Ok(());
6332            }
6333
6334            // Decode unknown envelopes for gaps in ordinals.
6335            while _next_ordinal_to_read < 8 {
6336                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6337                _next_ordinal_to_read += 1;
6338                next_offset += envelope_size;
6339            }
6340
6341            let next_out_of_line = decoder.next_out_of_line();
6342            let handles_before = decoder.remaining_handles();
6343            if let Some((inlined, num_bytes, num_handles)) =
6344                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6345            {
6346                let member_inline_size =
6347                    <UpstreamDnsCounters as fidl::encoding::TypeMarker>::inline_size(
6348                        decoder.context,
6349                    );
6350                if inlined != (member_inline_size <= 4) {
6351                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6352                }
6353                let inner_offset;
6354                let mut inner_depth = depth.clone();
6355                if inlined {
6356                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6357                    inner_offset = next_offset;
6358                } else {
6359                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6360                    inner_depth.increment()?;
6361                }
6362                let val_ref = self
6363                    .upstream_dns_counters
6364                    .get_or_insert_with(|| fidl::new_empty!(UpstreamDnsCounters, D));
6365                fidl::decode!(UpstreamDnsCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
6366                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6367                {
6368                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6369                }
6370                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6371                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6372                }
6373            }
6374
6375            next_offset += envelope_size;
6376
6377            // Decode the remaining unknown envelopes.
6378            while next_offset < end_offset {
6379                _next_ordinal_to_read += 1;
6380                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6381                next_offset += envelope_size;
6382            }
6383
6384            Ok(())
6385        }
6386    }
6387
6388    impl ExternalRoute {
6389        #[inline(always)]
6390        fn max_ordinal_present(&self) -> u64 {
6391            if let Some(_) = self.stable {
6392                return 3;
6393            }
6394            if let Some(_) = self.route_preference {
6395                return 2;
6396            }
6397            if let Some(_) = self.subnet {
6398                return 1;
6399            }
6400            0
6401        }
6402    }
6403
6404    impl fidl::encoding::ValueTypeMarker for ExternalRoute {
6405        type Borrowed<'a> = &'a Self;
6406        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6407            value
6408        }
6409    }
6410
6411    unsafe impl fidl::encoding::TypeMarker for ExternalRoute {
6412        type Owned = Self;
6413
6414        #[inline(always)]
6415        fn inline_align(_context: fidl::encoding::Context) -> usize {
6416            8
6417        }
6418
6419        #[inline(always)]
6420        fn inline_size(_context: fidl::encoding::Context) -> usize {
6421            16
6422        }
6423    }
6424
6425    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExternalRoute, D>
6426        for &ExternalRoute
6427    {
6428        unsafe fn encode(
6429            self,
6430            encoder: &mut fidl::encoding::Encoder<'_, D>,
6431            offset: usize,
6432            mut depth: fidl::encoding::Depth,
6433        ) -> fidl::Result<()> {
6434            encoder.debug_check_bounds::<ExternalRoute>(offset);
6435            // Vector header
6436            let max_ordinal: u64 = self.max_ordinal_present();
6437            encoder.write_num(max_ordinal, offset);
6438            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6439            // Calling encoder.out_of_line_offset(0) is not allowed.
6440            if max_ordinal == 0 {
6441                return Ok(());
6442            }
6443            depth.increment()?;
6444            let envelope_size = 8;
6445            let bytes_len = max_ordinal as usize * envelope_size;
6446            #[allow(unused_variables)]
6447            let offset = encoder.out_of_line_offset(bytes_len);
6448            let mut _prev_end_offset: usize = 0;
6449            if 1 > max_ordinal {
6450                return Ok(());
6451            }
6452
6453            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6454            // are envelope_size bytes.
6455            let cur_offset: usize = (1 - 1) * envelope_size;
6456
6457            // Zero reserved fields.
6458            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6459
6460            // Safety:
6461            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6462            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6463            //   envelope_size bytes, there is always sufficient room.
6464            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>(
6465            self.subnet.as_ref().map(<fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow),
6466            encoder, offset + cur_offset, depth
6467        )?;
6468
6469            _prev_end_offset = cur_offset + envelope_size;
6470            if 2 > max_ordinal {
6471                return Ok(());
6472            }
6473
6474            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6475            // are envelope_size bytes.
6476            let cur_offset: usize = (2 - 1) * envelope_size;
6477
6478            // Zero reserved fields.
6479            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6480
6481            // Safety:
6482            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6483            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6484            //   envelope_size bytes, there is always sufficient room.
6485            fidl::encoding::encode_in_envelope_optional::<RoutePreference, D>(
6486                self.route_preference
6487                    .as_ref()
6488                    .map(<RoutePreference as fidl::encoding::ValueTypeMarker>::borrow),
6489                encoder,
6490                offset + cur_offset,
6491                depth,
6492            )?;
6493
6494            _prev_end_offset = cur_offset + envelope_size;
6495            if 3 > max_ordinal {
6496                return Ok(());
6497            }
6498
6499            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6500            // are envelope_size bytes.
6501            let cur_offset: usize = (3 - 1) * envelope_size;
6502
6503            // Zero reserved fields.
6504            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6505
6506            // Safety:
6507            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6508            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6509            //   envelope_size bytes, there is always sufficient room.
6510            fidl::encoding::encode_in_envelope_optional::<bool, D>(
6511                self.stable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6512                encoder,
6513                offset + cur_offset,
6514                depth,
6515            )?;
6516
6517            _prev_end_offset = cur_offset + envelope_size;
6518
6519            Ok(())
6520        }
6521    }
6522
6523    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExternalRoute {
6524        #[inline(always)]
6525        fn new_empty() -> Self {
6526            Self::default()
6527        }
6528
6529        unsafe fn decode(
6530            &mut self,
6531            decoder: &mut fidl::encoding::Decoder<'_, D>,
6532            offset: usize,
6533            mut depth: fidl::encoding::Depth,
6534        ) -> fidl::Result<()> {
6535            decoder.debug_check_bounds::<Self>(offset);
6536            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6537                None => return Err(fidl::Error::NotNullable),
6538                Some(len) => len,
6539            };
6540            // Calling decoder.out_of_line_offset(0) is not allowed.
6541            if len == 0 {
6542                return Ok(());
6543            };
6544            depth.increment()?;
6545            let envelope_size = 8;
6546            let bytes_len = len * envelope_size;
6547            let offset = decoder.out_of_line_offset(bytes_len)?;
6548            // Decode the envelope for each type.
6549            let mut _next_ordinal_to_read = 0;
6550            let mut next_offset = offset;
6551            let end_offset = offset + bytes_len;
6552            _next_ordinal_to_read += 1;
6553            if next_offset >= end_offset {
6554                return Ok(());
6555            }
6556
6557            // Decode unknown envelopes for gaps in ordinals.
6558            while _next_ordinal_to_read < 1 {
6559                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6560                _next_ordinal_to_read += 1;
6561                next_offset += envelope_size;
6562            }
6563
6564            let next_out_of_line = decoder.next_out_of_line();
6565            let handles_before = decoder.remaining_handles();
6566            if let Some((inlined, num_bytes, num_handles)) =
6567                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6568            {
6569                let member_inline_size = <fidl_fuchsia_net__common::Ipv6AddressWithPrefix 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.subnet.get_or_insert_with(|| {
6583                    fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D)
6584                });
6585                fidl::decode!(
6586                    fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
6587                    D,
6588                    val_ref,
6589                    decoder,
6590                    inner_offset,
6591                    inner_depth
6592                )?;
6593                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6594                {
6595                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6596                }
6597                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6598                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6599                }
6600            }
6601
6602            next_offset += envelope_size;
6603            _next_ordinal_to_read += 1;
6604            if next_offset >= end_offset {
6605                return Ok(());
6606            }
6607
6608            // Decode unknown envelopes for gaps in ordinals.
6609            while _next_ordinal_to_read < 2 {
6610                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6611                _next_ordinal_to_read += 1;
6612                next_offset += envelope_size;
6613            }
6614
6615            let next_out_of_line = decoder.next_out_of_line();
6616            let handles_before = decoder.remaining_handles();
6617            if let Some((inlined, num_bytes, num_handles)) =
6618                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6619            {
6620                let member_inline_size =
6621                    <RoutePreference as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6622                if inlined != (member_inline_size <= 4) {
6623                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6624                }
6625                let inner_offset;
6626                let mut inner_depth = depth.clone();
6627                if inlined {
6628                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6629                    inner_offset = next_offset;
6630                } else {
6631                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6632                    inner_depth.increment()?;
6633                }
6634                let val_ref = self
6635                    .route_preference
6636                    .get_or_insert_with(|| fidl::new_empty!(RoutePreference, D));
6637                fidl::decode!(RoutePreference, D, val_ref, decoder, inner_offset, inner_depth)?;
6638                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6639                {
6640                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6641                }
6642                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6643                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6644                }
6645            }
6646
6647            next_offset += envelope_size;
6648            _next_ordinal_to_read += 1;
6649            if next_offset >= end_offset {
6650                return Ok(());
6651            }
6652
6653            // Decode unknown envelopes for gaps in ordinals.
6654            while _next_ordinal_to_read < 3 {
6655                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6656                _next_ordinal_to_read += 1;
6657                next_offset += envelope_size;
6658            }
6659
6660            let next_out_of_line = decoder.next_out_of_line();
6661            let handles_before = decoder.remaining_handles();
6662            if let Some((inlined, num_bytes, num_handles)) =
6663                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6664            {
6665                let member_inline_size =
6666                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6667                if inlined != (member_inline_size <= 4) {
6668                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6669                }
6670                let inner_offset;
6671                let mut inner_depth = depth.clone();
6672                if inlined {
6673                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6674                    inner_offset = next_offset;
6675                } else {
6676                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6677                    inner_depth.increment()?;
6678                }
6679                let val_ref = self.stable.get_or_insert_with(|| fidl::new_empty!(bool, D));
6680                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6681                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6682                {
6683                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6684                }
6685                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6686                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6687                }
6688            }
6689
6690            next_offset += envelope_size;
6691
6692            // Decode the remaining unknown envelopes.
6693            while next_offset < end_offset {
6694                _next_ordinal_to_read += 1;
6695                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6696                next_offset += envelope_size;
6697            }
6698
6699            Ok(())
6700        }
6701    }
6702
6703    impl JoinerCommissioningParams {
6704        #[inline(always)]
6705        fn max_ordinal_present(&self) -> u64 {
6706            if let Some(_) = self.vendor_data_string {
6707                return 6;
6708            }
6709            if let Some(_) = self.vendor_sw_version {
6710                return 5;
6711            }
6712            if let Some(_) = self.vendor_model {
6713                return 4;
6714            }
6715            if let Some(_) = self.vendor_name {
6716                return 3;
6717            }
6718            if let Some(_) = self.provisioning_url {
6719                return 2;
6720            }
6721            if let Some(_) = self.pskd {
6722                return 1;
6723            }
6724            0
6725        }
6726    }
6727
6728    impl fidl::encoding::ValueTypeMarker for JoinerCommissioningParams {
6729        type Borrowed<'a> = &'a Self;
6730        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6731            value
6732        }
6733    }
6734
6735    unsafe impl fidl::encoding::TypeMarker for JoinerCommissioningParams {
6736        type Owned = Self;
6737
6738        #[inline(always)]
6739        fn inline_align(_context: fidl::encoding::Context) -> usize {
6740            8
6741        }
6742
6743        #[inline(always)]
6744        fn inline_size(_context: fidl::encoding::Context) -> usize {
6745            16
6746        }
6747    }
6748
6749    unsafe impl<D: fidl::encoding::ResourceDialect>
6750        fidl::encoding::Encode<JoinerCommissioningParams, D> for &JoinerCommissioningParams
6751    {
6752        unsafe fn encode(
6753            self,
6754            encoder: &mut fidl::encoding::Encoder<'_, D>,
6755            offset: usize,
6756            mut depth: fidl::encoding::Depth,
6757        ) -> fidl::Result<()> {
6758            encoder.debug_check_bounds::<JoinerCommissioningParams>(offset);
6759            // Vector header
6760            let max_ordinal: u64 = self.max_ordinal_present();
6761            encoder.write_num(max_ordinal, offset);
6762            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6763            // Calling encoder.out_of_line_offset(0) is not allowed.
6764            if max_ordinal == 0 {
6765                return Ok(());
6766            }
6767            depth.increment()?;
6768            let envelope_size = 8;
6769            let bytes_len = max_ordinal as usize * envelope_size;
6770            #[allow(unused_variables)]
6771            let offset = encoder.out_of_line_offset(bytes_len);
6772            let mut _prev_end_offset: usize = 0;
6773            if 1 > max_ordinal {
6774                return Ok(());
6775            }
6776
6777            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6778            // are envelope_size bytes.
6779            let cur_offset: usize = (1 - 1) * envelope_size;
6780
6781            // Zero reserved fields.
6782            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6783
6784            // Safety:
6785            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6786            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6787            //   envelope_size bytes, there is always sufficient room.
6788            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<32>, D>(
6789                self.pskd.as_ref().map(
6790                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow,
6791                ),
6792                encoder,
6793                offset + cur_offset,
6794                depth,
6795            )?;
6796
6797            _prev_end_offset = cur_offset + envelope_size;
6798            if 2 > max_ordinal {
6799                return Ok(());
6800            }
6801
6802            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6803            // are envelope_size bytes.
6804            let cur_offset: usize = (2 - 1) * envelope_size;
6805
6806            // Zero reserved fields.
6807            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6808
6809            // Safety:
6810            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6811            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6812            //   envelope_size bytes, there is always sufficient room.
6813            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
6814                self.provisioning_url.as_ref().map(
6815                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
6816                ),
6817                encoder,
6818                offset + cur_offset,
6819                depth,
6820            )?;
6821
6822            _prev_end_offset = cur_offset + envelope_size;
6823            if 3 > max_ordinal {
6824                return Ok(());
6825            }
6826
6827            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6828            // are envelope_size bytes.
6829            let cur_offset: usize = (3 - 1) * envelope_size;
6830
6831            // Zero reserved fields.
6832            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6833
6834            // Safety:
6835            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6836            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6837            //   envelope_size bytes, there is always sufficient room.
6838            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<32>, D>(
6839                self.vendor_name.as_ref().map(
6840                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow,
6841                ),
6842                encoder,
6843                offset + cur_offset,
6844                depth,
6845            )?;
6846
6847            _prev_end_offset = cur_offset + envelope_size;
6848            if 4 > max_ordinal {
6849                return Ok(());
6850            }
6851
6852            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6853            // are envelope_size bytes.
6854            let cur_offset: usize = (4 - 1) * envelope_size;
6855
6856            // Zero reserved fields.
6857            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6858
6859            // Safety:
6860            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6861            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6862            //   envelope_size bytes, there is always sufficient room.
6863            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<32>, D>(
6864                self.vendor_model.as_ref().map(
6865                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow,
6866                ),
6867                encoder,
6868                offset + cur_offset,
6869                depth,
6870            )?;
6871
6872            _prev_end_offset = cur_offset + envelope_size;
6873            if 5 > max_ordinal {
6874                return Ok(());
6875            }
6876
6877            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6878            // are envelope_size bytes.
6879            let cur_offset: usize = (5 - 1) * envelope_size;
6880
6881            // Zero reserved fields.
6882            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6883
6884            // Safety:
6885            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6886            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6887            //   envelope_size bytes, there is always sufficient room.
6888            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<16>, D>(
6889                self.vendor_sw_version.as_ref().map(
6890                    <fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow,
6891                ),
6892                encoder,
6893                offset + cur_offset,
6894                depth,
6895            )?;
6896
6897            _prev_end_offset = cur_offset + envelope_size;
6898            if 6 > max_ordinal {
6899                return Ok(());
6900            }
6901
6902            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6903            // are envelope_size bytes.
6904            let cur_offset: usize = (6 - 1) * envelope_size;
6905
6906            // Zero reserved fields.
6907            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6908
6909            // Safety:
6910            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6911            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6912            //   envelope_size bytes, there is always sufficient room.
6913            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
6914                self.vendor_data_string.as_ref().map(
6915                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
6916                ),
6917                encoder,
6918                offset + cur_offset,
6919                depth,
6920            )?;
6921
6922            _prev_end_offset = cur_offset + envelope_size;
6923
6924            Ok(())
6925        }
6926    }
6927
6928    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6929        for JoinerCommissioningParams
6930    {
6931        #[inline(always)]
6932        fn new_empty() -> Self {
6933            Self::default()
6934        }
6935
6936        unsafe fn decode(
6937            &mut self,
6938            decoder: &mut fidl::encoding::Decoder<'_, D>,
6939            offset: usize,
6940            mut depth: fidl::encoding::Depth,
6941        ) -> fidl::Result<()> {
6942            decoder.debug_check_bounds::<Self>(offset);
6943            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6944                None => return Err(fidl::Error::NotNullable),
6945                Some(len) => len,
6946            };
6947            // Calling decoder.out_of_line_offset(0) is not allowed.
6948            if len == 0 {
6949                return Ok(());
6950            };
6951            depth.increment()?;
6952            let envelope_size = 8;
6953            let bytes_len = len * envelope_size;
6954            let offset = decoder.out_of_line_offset(bytes_len)?;
6955            // Decode the envelope for each type.
6956            let mut _next_ordinal_to_read = 0;
6957            let mut next_offset = offset;
6958            let end_offset = offset + bytes_len;
6959            _next_ordinal_to_read += 1;
6960            if next_offset >= end_offset {
6961                return Ok(());
6962            }
6963
6964            // Decode unknown envelopes for gaps in ordinals.
6965            while _next_ordinal_to_read < 1 {
6966                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6967                _next_ordinal_to_read += 1;
6968                next_offset += envelope_size;
6969            }
6970
6971            let next_out_of_line = decoder.next_out_of_line();
6972            let handles_before = decoder.remaining_handles();
6973            if let Some((inlined, num_bytes, num_handles)) =
6974                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6975            {
6976                let member_inline_size =
6977                    <fidl::encoding::BoundedString<32> as fidl::encoding::TypeMarker>::inline_size(
6978                        decoder.context,
6979                    );
6980                if inlined != (member_inline_size <= 4) {
6981                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6982                }
6983                let inner_offset;
6984                let mut inner_depth = depth.clone();
6985                if inlined {
6986                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6987                    inner_offset = next_offset;
6988                } else {
6989                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6990                    inner_depth.increment()?;
6991                }
6992                let val_ref = self
6993                    .pskd
6994                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<32>, D));
6995                fidl::decode!(
6996                    fidl::encoding::BoundedString<32>,
6997                    D,
6998                    val_ref,
6999                    decoder,
7000                    inner_offset,
7001                    inner_depth
7002                )?;
7003                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7004                {
7005                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7006                }
7007                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7008                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7009                }
7010            }
7011
7012            next_offset += envelope_size;
7013            _next_ordinal_to_read += 1;
7014            if next_offset >= end_offset {
7015                return Ok(());
7016            }
7017
7018            // Decode unknown envelopes for gaps in ordinals.
7019            while _next_ordinal_to_read < 2 {
7020                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7021                _next_ordinal_to_read += 1;
7022                next_offset += envelope_size;
7023            }
7024
7025            let next_out_of_line = decoder.next_out_of_line();
7026            let handles_before = decoder.remaining_handles();
7027            if let Some((inlined, num_bytes, num_handles)) =
7028                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7029            {
7030                let member_inline_size =
7031                    <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
7032                        decoder.context,
7033                    );
7034                if inlined != (member_inline_size <= 4) {
7035                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7036                }
7037                let inner_offset;
7038                let mut inner_depth = depth.clone();
7039                if inlined {
7040                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7041                    inner_offset = next_offset;
7042                } else {
7043                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7044                    inner_depth.increment()?;
7045                }
7046                let val_ref = self
7047                    .provisioning_url
7048                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
7049                fidl::decode!(
7050                    fidl::encoding::BoundedString<64>,
7051                    D,
7052                    val_ref,
7053                    decoder,
7054                    inner_offset,
7055                    inner_depth
7056                )?;
7057                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7058                {
7059                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7060                }
7061                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7062                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7063                }
7064            }
7065
7066            next_offset += envelope_size;
7067            _next_ordinal_to_read += 1;
7068            if next_offset >= end_offset {
7069                return Ok(());
7070            }
7071
7072            // Decode unknown envelopes for gaps in ordinals.
7073            while _next_ordinal_to_read < 3 {
7074                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7075                _next_ordinal_to_read += 1;
7076                next_offset += envelope_size;
7077            }
7078
7079            let next_out_of_line = decoder.next_out_of_line();
7080            let handles_before = decoder.remaining_handles();
7081            if let Some((inlined, num_bytes, num_handles)) =
7082                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7083            {
7084                let member_inline_size =
7085                    <fidl::encoding::BoundedString<32> as fidl::encoding::TypeMarker>::inline_size(
7086                        decoder.context,
7087                    );
7088                if inlined != (member_inline_size <= 4) {
7089                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7090                }
7091                let inner_offset;
7092                let mut inner_depth = depth.clone();
7093                if inlined {
7094                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7095                    inner_offset = next_offset;
7096                } else {
7097                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7098                    inner_depth.increment()?;
7099                }
7100                let val_ref = self
7101                    .vendor_name
7102                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<32>, D));
7103                fidl::decode!(
7104                    fidl::encoding::BoundedString<32>,
7105                    D,
7106                    val_ref,
7107                    decoder,
7108                    inner_offset,
7109                    inner_depth
7110                )?;
7111                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7112                {
7113                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7114                }
7115                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7116                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7117                }
7118            }
7119
7120            next_offset += envelope_size;
7121            _next_ordinal_to_read += 1;
7122            if next_offset >= end_offset {
7123                return Ok(());
7124            }
7125
7126            // Decode unknown envelopes for gaps in ordinals.
7127            while _next_ordinal_to_read < 4 {
7128                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7129                _next_ordinal_to_read += 1;
7130                next_offset += envelope_size;
7131            }
7132
7133            let next_out_of_line = decoder.next_out_of_line();
7134            let handles_before = decoder.remaining_handles();
7135            if let Some((inlined, num_bytes, num_handles)) =
7136                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7137            {
7138                let member_inline_size =
7139                    <fidl::encoding::BoundedString<32> as fidl::encoding::TypeMarker>::inline_size(
7140                        decoder.context,
7141                    );
7142                if inlined != (member_inline_size <= 4) {
7143                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7144                }
7145                let inner_offset;
7146                let mut inner_depth = depth.clone();
7147                if inlined {
7148                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7149                    inner_offset = next_offset;
7150                } else {
7151                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7152                    inner_depth.increment()?;
7153                }
7154                let val_ref = self
7155                    .vendor_model
7156                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<32>, D));
7157                fidl::decode!(
7158                    fidl::encoding::BoundedString<32>,
7159                    D,
7160                    val_ref,
7161                    decoder,
7162                    inner_offset,
7163                    inner_depth
7164                )?;
7165                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7166                {
7167                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7168                }
7169                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7170                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7171                }
7172            }
7173
7174            next_offset += envelope_size;
7175            _next_ordinal_to_read += 1;
7176            if next_offset >= end_offset {
7177                return Ok(());
7178            }
7179
7180            // Decode unknown envelopes for gaps in ordinals.
7181            while _next_ordinal_to_read < 5 {
7182                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7183                _next_ordinal_to_read += 1;
7184                next_offset += envelope_size;
7185            }
7186
7187            let next_out_of_line = decoder.next_out_of_line();
7188            let handles_before = decoder.remaining_handles();
7189            if let Some((inlined, num_bytes, num_handles)) =
7190                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7191            {
7192                let member_inline_size =
7193                    <fidl::encoding::BoundedString<16> as fidl::encoding::TypeMarker>::inline_size(
7194                        decoder.context,
7195                    );
7196                if inlined != (member_inline_size <= 4) {
7197                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7198                }
7199                let inner_offset;
7200                let mut inner_depth = depth.clone();
7201                if inlined {
7202                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7203                    inner_offset = next_offset;
7204                } else {
7205                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7206                    inner_depth.increment()?;
7207                }
7208                let val_ref = self
7209                    .vendor_sw_version
7210                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<16>, D));
7211                fidl::decode!(
7212                    fidl::encoding::BoundedString<16>,
7213                    D,
7214                    val_ref,
7215                    decoder,
7216                    inner_offset,
7217                    inner_depth
7218                )?;
7219                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7220                {
7221                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7222                }
7223                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7224                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7225                }
7226            }
7227
7228            next_offset += envelope_size;
7229            _next_ordinal_to_read += 1;
7230            if next_offset >= end_offset {
7231                return Ok(());
7232            }
7233
7234            // Decode unknown envelopes for gaps in ordinals.
7235            while _next_ordinal_to_read < 6 {
7236                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7237                _next_ordinal_to_read += 1;
7238                next_offset += envelope_size;
7239            }
7240
7241            let next_out_of_line = decoder.next_out_of_line();
7242            let handles_before = decoder.remaining_handles();
7243            if let Some((inlined, num_bytes, num_handles)) =
7244                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7245            {
7246                let member_inline_size =
7247                    <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
7248                        decoder.context,
7249                    );
7250                if inlined != (member_inline_size <= 4) {
7251                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7252                }
7253                let inner_offset;
7254                let mut inner_depth = depth.clone();
7255                if inlined {
7256                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7257                    inner_offset = next_offset;
7258                } else {
7259                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7260                    inner_depth.increment()?;
7261                }
7262                let val_ref = self
7263                    .vendor_data_string
7264                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
7265                fidl::decode!(
7266                    fidl::encoding::BoundedString<64>,
7267                    D,
7268                    val_ref,
7269                    decoder,
7270                    inner_offset,
7271                    inner_depth
7272                )?;
7273                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7274                {
7275                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7276                }
7277                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7278                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7279                }
7280            }
7281
7282            next_offset += envelope_size;
7283
7284            // Decode the remaining unknown envelopes.
7285            while next_offset < end_offset {
7286                _next_ordinal_to_read += 1;
7287                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7288                next_offset += envelope_size;
7289            }
7290
7291            Ok(())
7292        }
7293    }
7294
7295    impl LeaderData {
7296        #[inline(always)]
7297        fn max_ordinal_present(&self) -> u64 {
7298            if let Some(_) = self.router_id {
7299                return 5;
7300            }
7301            if let Some(_) = self.stable_network_data_version {
7302                return 4;
7303            }
7304            if let Some(_) = self.network_data_version {
7305                return 3;
7306            }
7307            if let Some(_) = self.weight {
7308                return 2;
7309            }
7310            if let Some(_) = self.partition_id {
7311                return 1;
7312            }
7313            0
7314        }
7315    }
7316
7317    impl fidl::encoding::ValueTypeMarker for LeaderData {
7318        type Borrowed<'a> = &'a Self;
7319        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7320            value
7321        }
7322    }
7323
7324    unsafe impl fidl::encoding::TypeMarker for LeaderData {
7325        type Owned = Self;
7326
7327        #[inline(always)]
7328        fn inline_align(_context: fidl::encoding::Context) -> usize {
7329            8
7330        }
7331
7332        #[inline(always)]
7333        fn inline_size(_context: fidl::encoding::Context) -> usize {
7334            16
7335        }
7336    }
7337
7338    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LeaderData, D>
7339        for &LeaderData
7340    {
7341        unsafe fn encode(
7342            self,
7343            encoder: &mut fidl::encoding::Encoder<'_, D>,
7344            offset: usize,
7345            mut depth: fidl::encoding::Depth,
7346        ) -> fidl::Result<()> {
7347            encoder.debug_check_bounds::<LeaderData>(offset);
7348            // Vector header
7349            let max_ordinal: u64 = self.max_ordinal_present();
7350            encoder.write_num(max_ordinal, offset);
7351            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7352            // Calling encoder.out_of_line_offset(0) is not allowed.
7353            if max_ordinal == 0 {
7354                return Ok(());
7355            }
7356            depth.increment()?;
7357            let envelope_size = 8;
7358            let bytes_len = max_ordinal as usize * envelope_size;
7359            #[allow(unused_variables)]
7360            let offset = encoder.out_of_line_offset(bytes_len);
7361            let mut _prev_end_offset: usize = 0;
7362            if 1 > max_ordinal {
7363                return Ok(());
7364            }
7365
7366            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7367            // are envelope_size bytes.
7368            let cur_offset: usize = (1 - 1) * envelope_size;
7369
7370            // Zero reserved fields.
7371            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7372
7373            // Safety:
7374            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7375            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7376            //   envelope_size bytes, there is always sufficient room.
7377            fidl::encoding::encode_in_envelope_optional::<u32, D>(
7378                self.partition_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
7379                encoder,
7380                offset + cur_offset,
7381                depth,
7382            )?;
7383
7384            _prev_end_offset = cur_offset + envelope_size;
7385            if 2 > max_ordinal {
7386                return Ok(());
7387            }
7388
7389            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7390            // are envelope_size bytes.
7391            let cur_offset: usize = (2 - 1) * envelope_size;
7392
7393            // Zero reserved fields.
7394            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7395
7396            // Safety:
7397            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7398            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7399            //   envelope_size bytes, there is always sufficient room.
7400            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7401                self.weight.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7402                encoder,
7403                offset + cur_offset,
7404                depth,
7405            )?;
7406
7407            _prev_end_offset = cur_offset + envelope_size;
7408            if 3 > max_ordinal {
7409                return Ok(());
7410            }
7411
7412            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7413            // are envelope_size bytes.
7414            let cur_offset: usize = (3 - 1) * envelope_size;
7415
7416            // Zero reserved fields.
7417            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7418
7419            // Safety:
7420            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7421            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7422            //   envelope_size bytes, there is always sufficient room.
7423            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7424                self.network_data_version
7425                    .as_ref()
7426                    .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7427                encoder,
7428                offset + cur_offset,
7429                depth,
7430            )?;
7431
7432            _prev_end_offset = cur_offset + envelope_size;
7433            if 4 > max_ordinal {
7434                return Ok(());
7435            }
7436
7437            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7438            // are envelope_size bytes.
7439            let cur_offset: usize = (4 - 1) * envelope_size;
7440
7441            // Zero reserved fields.
7442            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7443
7444            // Safety:
7445            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7446            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7447            //   envelope_size bytes, there is always sufficient room.
7448            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7449                self.stable_network_data_version
7450                    .as_ref()
7451                    .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7452                encoder,
7453                offset + cur_offset,
7454                depth,
7455            )?;
7456
7457            _prev_end_offset = cur_offset + envelope_size;
7458            if 5 > max_ordinal {
7459                return Ok(());
7460            }
7461
7462            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7463            // are envelope_size bytes.
7464            let cur_offset: usize = (5 - 1) * envelope_size;
7465
7466            // Zero reserved fields.
7467            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7468
7469            // Safety:
7470            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7471            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7472            //   envelope_size bytes, there is always sufficient room.
7473            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7474                self.router_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7475                encoder,
7476                offset + cur_offset,
7477                depth,
7478            )?;
7479
7480            _prev_end_offset = cur_offset + envelope_size;
7481
7482            Ok(())
7483        }
7484    }
7485
7486    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LeaderData {
7487        #[inline(always)]
7488        fn new_empty() -> Self {
7489            Self::default()
7490        }
7491
7492        unsafe fn decode(
7493            &mut self,
7494            decoder: &mut fidl::encoding::Decoder<'_, D>,
7495            offset: usize,
7496            mut depth: fidl::encoding::Depth,
7497        ) -> fidl::Result<()> {
7498            decoder.debug_check_bounds::<Self>(offset);
7499            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7500                None => return Err(fidl::Error::NotNullable),
7501                Some(len) => len,
7502            };
7503            // Calling decoder.out_of_line_offset(0) is not allowed.
7504            if len == 0 {
7505                return Ok(());
7506            };
7507            depth.increment()?;
7508            let envelope_size = 8;
7509            let bytes_len = len * envelope_size;
7510            let offset = decoder.out_of_line_offset(bytes_len)?;
7511            // Decode the envelope for each type.
7512            let mut _next_ordinal_to_read = 0;
7513            let mut next_offset = offset;
7514            let end_offset = offset + bytes_len;
7515            _next_ordinal_to_read += 1;
7516            if next_offset >= end_offset {
7517                return Ok(());
7518            }
7519
7520            // Decode unknown envelopes for gaps in ordinals.
7521            while _next_ordinal_to_read < 1 {
7522                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7523                _next_ordinal_to_read += 1;
7524                next_offset += envelope_size;
7525            }
7526
7527            let next_out_of_line = decoder.next_out_of_line();
7528            let handles_before = decoder.remaining_handles();
7529            if let Some((inlined, num_bytes, num_handles)) =
7530                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7531            {
7532                let member_inline_size =
7533                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7534                if inlined != (member_inline_size <= 4) {
7535                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7536                }
7537                let inner_offset;
7538                let mut inner_depth = depth.clone();
7539                if inlined {
7540                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7541                    inner_offset = next_offset;
7542                } else {
7543                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7544                    inner_depth.increment()?;
7545                }
7546                let val_ref = self.partition_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
7547                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7548                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7549                {
7550                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7551                }
7552                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7553                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7554                }
7555            }
7556
7557            next_offset += envelope_size;
7558            _next_ordinal_to_read += 1;
7559            if next_offset >= end_offset {
7560                return Ok(());
7561            }
7562
7563            // Decode unknown envelopes for gaps in ordinals.
7564            while _next_ordinal_to_read < 2 {
7565                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7566                _next_ordinal_to_read += 1;
7567                next_offset += envelope_size;
7568            }
7569
7570            let next_out_of_line = decoder.next_out_of_line();
7571            let handles_before = decoder.remaining_handles();
7572            if let Some((inlined, num_bytes, num_handles)) =
7573                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7574            {
7575                let member_inline_size =
7576                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7577                if inlined != (member_inline_size <= 4) {
7578                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7579                }
7580                let inner_offset;
7581                let mut inner_depth = depth.clone();
7582                if inlined {
7583                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7584                    inner_offset = next_offset;
7585                } else {
7586                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7587                    inner_depth.increment()?;
7588                }
7589                let val_ref = self.weight.get_or_insert_with(|| fidl::new_empty!(u8, D));
7590                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7591                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7592                {
7593                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7594                }
7595                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7596                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7597                }
7598            }
7599
7600            next_offset += envelope_size;
7601            _next_ordinal_to_read += 1;
7602            if next_offset >= end_offset {
7603                return Ok(());
7604            }
7605
7606            // Decode unknown envelopes for gaps in ordinals.
7607            while _next_ordinal_to_read < 3 {
7608                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7609                _next_ordinal_to_read += 1;
7610                next_offset += envelope_size;
7611            }
7612
7613            let next_out_of_line = decoder.next_out_of_line();
7614            let handles_before = decoder.remaining_handles();
7615            if let Some((inlined, num_bytes, num_handles)) =
7616                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7617            {
7618                let member_inline_size =
7619                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7620                if inlined != (member_inline_size <= 4) {
7621                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7622                }
7623                let inner_offset;
7624                let mut inner_depth = depth.clone();
7625                if inlined {
7626                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7627                    inner_offset = next_offset;
7628                } else {
7629                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7630                    inner_depth.increment()?;
7631                }
7632                let val_ref =
7633                    self.network_data_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
7634                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7635                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7636                {
7637                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7638                }
7639                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7640                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7641                }
7642            }
7643
7644            next_offset += envelope_size;
7645            _next_ordinal_to_read += 1;
7646            if next_offset >= end_offset {
7647                return Ok(());
7648            }
7649
7650            // Decode unknown envelopes for gaps in ordinals.
7651            while _next_ordinal_to_read < 4 {
7652                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7653                _next_ordinal_to_read += 1;
7654                next_offset += envelope_size;
7655            }
7656
7657            let next_out_of_line = decoder.next_out_of_line();
7658            let handles_before = decoder.remaining_handles();
7659            if let Some((inlined, num_bytes, num_handles)) =
7660                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7661            {
7662                let member_inline_size =
7663                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7664                if inlined != (member_inline_size <= 4) {
7665                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7666                }
7667                let inner_offset;
7668                let mut inner_depth = depth.clone();
7669                if inlined {
7670                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7671                    inner_offset = next_offset;
7672                } else {
7673                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7674                    inner_depth.increment()?;
7675                }
7676                let val_ref =
7677                    self.stable_network_data_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
7678                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7679                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7680                {
7681                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7682                }
7683                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7684                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7685                }
7686            }
7687
7688            next_offset += envelope_size;
7689            _next_ordinal_to_read += 1;
7690            if next_offset >= end_offset {
7691                return Ok(());
7692            }
7693
7694            // Decode unknown envelopes for gaps in ordinals.
7695            while _next_ordinal_to_read < 5 {
7696                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7697                _next_ordinal_to_read += 1;
7698                next_offset += envelope_size;
7699            }
7700
7701            let next_out_of_line = decoder.next_out_of_line();
7702            let handles_before = decoder.remaining_handles();
7703            if let Some((inlined, num_bytes, num_handles)) =
7704                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7705            {
7706                let member_inline_size =
7707                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7708                if inlined != (member_inline_size <= 4) {
7709                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7710                }
7711                let inner_offset;
7712                let mut inner_depth = depth.clone();
7713                if inlined {
7714                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7715                    inner_offset = next_offset;
7716                } else {
7717                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7718                    inner_depth.increment()?;
7719                }
7720                let val_ref = self.router_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
7721                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7722                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7723                {
7724                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7725                }
7726                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7727                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7728                }
7729            }
7730
7731            next_offset += envelope_size;
7732
7733            // Decode the remaining unknown envelopes.
7734            while next_offset < end_offset {
7735                _next_ordinal_to_read += 1;
7736                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7737                next_offset += envelope_size;
7738            }
7739
7740            Ok(())
7741        }
7742    }
7743
7744    impl LinkMetricsEntry {
7745        #[inline(always)]
7746        fn max_ordinal_present(&self) -> u64 {
7747            if let Some(_) = self.rssi {
7748                return 2;
7749            }
7750            if let Some(_) = self.link_margin {
7751                return 1;
7752            }
7753            0
7754        }
7755    }
7756
7757    impl fidl::encoding::ValueTypeMarker for LinkMetricsEntry {
7758        type Borrowed<'a> = &'a Self;
7759        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7760            value
7761        }
7762    }
7763
7764    unsafe impl fidl::encoding::TypeMarker for LinkMetricsEntry {
7765        type Owned = Self;
7766
7767        #[inline(always)]
7768        fn inline_align(_context: fidl::encoding::Context) -> usize {
7769            8
7770        }
7771
7772        #[inline(always)]
7773        fn inline_size(_context: fidl::encoding::Context) -> usize {
7774            16
7775        }
7776    }
7777
7778    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LinkMetricsEntry, D>
7779        for &LinkMetricsEntry
7780    {
7781        unsafe fn encode(
7782            self,
7783            encoder: &mut fidl::encoding::Encoder<'_, D>,
7784            offset: usize,
7785            mut depth: fidl::encoding::Depth,
7786        ) -> fidl::Result<()> {
7787            encoder.debug_check_bounds::<LinkMetricsEntry>(offset);
7788            // Vector header
7789            let max_ordinal: u64 = self.max_ordinal_present();
7790            encoder.write_num(max_ordinal, offset);
7791            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7792            // Calling encoder.out_of_line_offset(0) is not allowed.
7793            if max_ordinal == 0 {
7794                return Ok(());
7795            }
7796            depth.increment()?;
7797            let envelope_size = 8;
7798            let bytes_len = max_ordinal as usize * envelope_size;
7799            #[allow(unused_variables)]
7800            let offset = encoder.out_of_line_offset(bytes_len);
7801            let mut _prev_end_offset: usize = 0;
7802            if 1 > max_ordinal {
7803                return Ok(());
7804            }
7805
7806            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7807            // are envelope_size bytes.
7808            let cur_offset: usize = (1 - 1) * envelope_size;
7809
7810            // Zero reserved fields.
7811            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7812
7813            // Safety:
7814            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7815            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7816            //   envelope_size bytes, there is always sufficient room.
7817            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7818                self.link_margin.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7819                encoder,
7820                offset + cur_offset,
7821                depth,
7822            )?;
7823
7824            _prev_end_offset = cur_offset + envelope_size;
7825            if 2 > max_ordinal {
7826                return Ok(());
7827            }
7828
7829            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7830            // are envelope_size bytes.
7831            let cur_offset: usize = (2 - 1) * envelope_size;
7832
7833            // Zero reserved fields.
7834            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7835
7836            // Safety:
7837            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7838            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7839            //   envelope_size bytes, there is always sufficient room.
7840            fidl::encoding::encode_in_envelope_optional::<i8, D>(
7841                self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
7842                encoder,
7843                offset + cur_offset,
7844                depth,
7845            )?;
7846
7847            _prev_end_offset = cur_offset + envelope_size;
7848
7849            Ok(())
7850        }
7851    }
7852
7853    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LinkMetricsEntry {
7854        #[inline(always)]
7855        fn new_empty() -> Self {
7856            Self::default()
7857        }
7858
7859        unsafe fn decode(
7860            &mut self,
7861            decoder: &mut fidl::encoding::Decoder<'_, D>,
7862            offset: usize,
7863            mut depth: fidl::encoding::Depth,
7864        ) -> fidl::Result<()> {
7865            decoder.debug_check_bounds::<Self>(offset);
7866            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7867                None => return Err(fidl::Error::NotNullable),
7868                Some(len) => len,
7869            };
7870            // Calling decoder.out_of_line_offset(0) is not allowed.
7871            if len == 0 {
7872                return Ok(());
7873            };
7874            depth.increment()?;
7875            let envelope_size = 8;
7876            let bytes_len = len * envelope_size;
7877            let offset = decoder.out_of_line_offset(bytes_len)?;
7878            // Decode the envelope for each type.
7879            let mut _next_ordinal_to_read = 0;
7880            let mut next_offset = offset;
7881            let end_offset = offset + bytes_len;
7882            _next_ordinal_to_read += 1;
7883            if next_offset >= end_offset {
7884                return Ok(());
7885            }
7886
7887            // Decode unknown envelopes for gaps in ordinals.
7888            while _next_ordinal_to_read < 1 {
7889                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7890                _next_ordinal_to_read += 1;
7891                next_offset += envelope_size;
7892            }
7893
7894            let next_out_of_line = decoder.next_out_of_line();
7895            let handles_before = decoder.remaining_handles();
7896            if let Some((inlined, num_bytes, num_handles)) =
7897                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7898            {
7899                let member_inline_size =
7900                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7901                if inlined != (member_inline_size <= 4) {
7902                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7903                }
7904                let inner_offset;
7905                let mut inner_depth = depth.clone();
7906                if inlined {
7907                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7908                    inner_offset = next_offset;
7909                } else {
7910                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7911                    inner_depth.increment()?;
7912                }
7913                let val_ref = self.link_margin.get_or_insert_with(|| fidl::new_empty!(u8, D));
7914                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7915                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7916                {
7917                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7918                }
7919                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7920                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7921                }
7922            }
7923
7924            next_offset += envelope_size;
7925            _next_ordinal_to_read += 1;
7926            if next_offset >= end_offset {
7927                return Ok(());
7928            }
7929
7930            // Decode unknown envelopes for gaps in ordinals.
7931            while _next_ordinal_to_read < 2 {
7932                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7933                _next_ordinal_to_read += 1;
7934                next_offset += envelope_size;
7935            }
7936
7937            let next_out_of_line = decoder.next_out_of_line();
7938            let handles_before = decoder.remaining_handles();
7939            if let Some((inlined, num_bytes, num_handles)) =
7940                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7941            {
7942                let member_inline_size =
7943                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7944                if inlined != (member_inline_size <= 4) {
7945                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7946                }
7947                let inner_offset;
7948                let mut inner_depth = depth.clone();
7949                if inlined {
7950                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7951                    inner_offset = next_offset;
7952                } else {
7953                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7954                    inner_depth.increment()?;
7955                }
7956                let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
7957                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
7958                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7959                {
7960                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7961                }
7962                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7963                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7964                }
7965            }
7966
7967            next_offset += envelope_size;
7968
7969            // Decode the remaining unknown envelopes.
7970            while next_offset < end_offset {
7971                _next_ordinal_to_read += 1;
7972                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7973                next_offset += envelope_size;
7974            }
7975
7976            Ok(())
7977        }
7978    }
7979
7980    impl Nat64ErrorCounters {
7981        #[inline(always)]
7982        fn max_ordinal_present(&self) -> u64 {
7983            if let Some(_) = self.no_mapping {
7984                return 4;
7985            }
7986            if let Some(_) = self.unsupported_protocol {
7987                return 3;
7988            }
7989            if let Some(_) = self.illegal_packet {
7990                return 2;
7991            }
7992            if let Some(_) = self.unknown {
7993                return 1;
7994            }
7995            0
7996        }
7997    }
7998
7999    impl fidl::encoding::ValueTypeMarker for Nat64ErrorCounters {
8000        type Borrowed<'a> = &'a Self;
8001        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8002            value
8003        }
8004    }
8005
8006    unsafe impl fidl::encoding::TypeMarker for Nat64ErrorCounters {
8007        type Owned = Self;
8008
8009        #[inline(always)]
8010        fn inline_align(_context: fidl::encoding::Context) -> usize {
8011            8
8012        }
8013
8014        #[inline(always)]
8015        fn inline_size(_context: fidl::encoding::Context) -> usize {
8016            16
8017        }
8018    }
8019
8020    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64ErrorCounters, D>
8021        for &Nat64ErrorCounters
8022    {
8023        unsafe fn encode(
8024            self,
8025            encoder: &mut fidl::encoding::Encoder<'_, D>,
8026            offset: usize,
8027            mut depth: fidl::encoding::Depth,
8028        ) -> fidl::Result<()> {
8029            encoder.debug_check_bounds::<Nat64ErrorCounters>(offset);
8030            // Vector header
8031            let max_ordinal: u64 = self.max_ordinal_present();
8032            encoder.write_num(max_ordinal, offset);
8033            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8034            // Calling encoder.out_of_line_offset(0) is not allowed.
8035            if max_ordinal == 0 {
8036                return Ok(());
8037            }
8038            depth.increment()?;
8039            let envelope_size = 8;
8040            let bytes_len = max_ordinal as usize * envelope_size;
8041            #[allow(unused_variables)]
8042            let offset = encoder.out_of_line_offset(bytes_len);
8043            let mut _prev_end_offset: usize = 0;
8044            if 1 > max_ordinal {
8045                return Ok(());
8046            }
8047
8048            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8049            // are envelope_size bytes.
8050            let cur_offset: usize = (1 - 1) * envelope_size;
8051
8052            // Zero reserved fields.
8053            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8054
8055            // Safety:
8056            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8057            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8058            //   envelope_size bytes, there is always sufficient room.
8059            fidl::encoding::encode_in_envelope_optional::<Nat64PacketCounters, D>(
8060                self.unknown
8061                    .as_ref()
8062                    .map(<Nat64PacketCounters as fidl::encoding::ValueTypeMarker>::borrow),
8063                encoder,
8064                offset + cur_offset,
8065                depth,
8066            )?;
8067
8068            _prev_end_offset = cur_offset + envelope_size;
8069            if 2 > max_ordinal {
8070                return Ok(());
8071            }
8072
8073            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8074            // are envelope_size bytes.
8075            let cur_offset: usize = (2 - 1) * envelope_size;
8076
8077            // Zero reserved fields.
8078            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8079
8080            // Safety:
8081            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8082            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8083            //   envelope_size bytes, there is always sufficient room.
8084            fidl::encoding::encode_in_envelope_optional::<Nat64PacketCounters, D>(
8085                self.illegal_packet
8086                    .as_ref()
8087                    .map(<Nat64PacketCounters as fidl::encoding::ValueTypeMarker>::borrow),
8088                encoder,
8089                offset + cur_offset,
8090                depth,
8091            )?;
8092
8093            _prev_end_offset = cur_offset + envelope_size;
8094            if 3 > max_ordinal {
8095                return Ok(());
8096            }
8097
8098            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8099            // are envelope_size bytes.
8100            let cur_offset: usize = (3 - 1) * envelope_size;
8101
8102            // Zero reserved fields.
8103            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8104
8105            // Safety:
8106            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8107            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8108            //   envelope_size bytes, there is always sufficient room.
8109            fidl::encoding::encode_in_envelope_optional::<Nat64PacketCounters, D>(
8110                self.unsupported_protocol
8111                    .as_ref()
8112                    .map(<Nat64PacketCounters as fidl::encoding::ValueTypeMarker>::borrow),
8113                encoder,
8114                offset + cur_offset,
8115                depth,
8116            )?;
8117
8118            _prev_end_offset = cur_offset + envelope_size;
8119            if 4 > max_ordinal {
8120                return Ok(());
8121            }
8122
8123            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8124            // are envelope_size bytes.
8125            let cur_offset: usize = (4 - 1) * envelope_size;
8126
8127            // Zero reserved fields.
8128            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8129
8130            // Safety:
8131            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8132            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8133            //   envelope_size bytes, there is always sufficient room.
8134            fidl::encoding::encode_in_envelope_optional::<Nat64PacketCounters, D>(
8135                self.no_mapping
8136                    .as_ref()
8137                    .map(<Nat64PacketCounters as fidl::encoding::ValueTypeMarker>::borrow),
8138                encoder,
8139                offset + cur_offset,
8140                depth,
8141            )?;
8142
8143            _prev_end_offset = cur_offset + envelope_size;
8144
8145            Ok(())
8146        }
8147    }
8148
8149    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64ErrorCounters {
8150        #[inline(always)]
8151        fn new_empty() -> Self {
8152            Self::default()
8153        }
8154
8155        unsafe fn decode(
8156            &mut self,
8157            decoder: &mut fidl::encoding::Decoder<'_, D>,
8158            offset: usize,
8159            mut depth: fidl::encoding::Depth,
8160        ) -> fidl::Result<()> {
8161            decoder.debug_check_bounds::<Self>(offset);
8162            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8163                None => return Err(fidl::Error::NotNullable),
8164                Some(len) => len,
8165            };
8166            // Calling decoder.out_of_line_offset(0) is not allowed.
8167            if len == 0 {
8168                return Ok(());
8169            };
8170            depth.increment()?;
8171            let envelope_size = 8;
8172            let bytes_len = len * envelope_size;
8173            let offset = decoder.out_of_line_offset(bytes_len)?;
8174            // Decode the envelope for each type.
8175            let mut _next_ordinal_to_read = 0;
8176            let mut next_offset = offset;
8177            let end_offset = offset + bytes_len;
8178            _next_ordinal_to_read += 1;
8179            if next_offset >= end_offset {
8180                return Ok(());
8181            }
8182
8183            // Decode unknown envelopes for gaps in ordinals.
8184            while _next_ordinal_to_read < 1 {
8185                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8186                _next_ordinal_to_read += 1;
8187                next_offset += envelope_size;
8188            }
8189
8190            let next_out_of_line = decoder.next_out_of_line();
8191            let handles_before = decoder.remaining_handles();
8192            if let Some((inlined, num_bytes, num_handles)) =
8193                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8194            {
8195                let member_inline_size =
8196                    <Nat64PacketCounters as fidl::encoding::TypeMarker>::inline_size(
8197                        decoder.context,
8198                    );
8199                if inlined != (member_inline_size <= 4) {
8200                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8201                }
8202                let inner_offset;
8203                let mut inner_depth = depth.clone();
8204                if inlined {
8205                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8206                    inner_offset = next_offset;
8207                } else {
8208                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8209                    inner_depth.increment()?;
8210                }
8211                let val_ref =
8212                    self.unknown.get_or_insert_with(|| fidl::new_empty!(Nat64PacketCounters, D));
8213                fidl::decode!(Nat64PacketCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8214                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8215                {
8216                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8217                }
8218                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8219                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8220                }
8221            }
8222
8223            next_offset += envelope_size;
8224            _next_ordinal_to_read += 1;
8225            if next_offset >= end_offset {
8226                return Ok(());
8227            }
8228
8229            // Decode unknown envelopes for gaps in ordinals.
8230            while _next_ordinal_to_read < 2 {
8231                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8232                _next_ordinal_to_read += 1;
8233                next_offset += envelope_size;
8234            }
8235
8236            let next_out_of_line = decoder.next_out_of_line();
8237            let handles_before = decoder.remaining_handles();
8238            if let Some((inlined, num_bytes, num_handles)) =
8239                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8240            {
8241                let member_inline_size =
8242                    <Nat64PacketCounters as fidl::encoding::TypeMarker>::inline_size(
8243                        decoder.context,
8244                    );
8245                if inlined != (member_inline_size <= 4) {
8246                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8247                }
8248                let inner_offset;
8249                let mut inner_depth = depth.clone();
8250                if inlined {
8251                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8252                    inner_offset = next_offset;
8253                } else {
8254                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8255                    inner_depth.increment()?;
8256                }
8257                let val_ref = self
8258                    .illegal_packet
8259                    .get_or_insert_with(|| fidl::new_empty!(Nat64PacketCounters, D));
8260                fidl::decode!(Nat64PacketCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8261                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8262                {
8263                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8264                }
8265                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8266                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8267                }
8268            }
8269
8270            next_offset += envelope_size;
8271            _next_ordinal_to_read += 1;
8272            if next_offset >= end_offset {
8273                return Ok(());
8274            }
8275
8276            // Decode unknown envelopes for gaps in ordinals.
8277            while _next_ordinal_to_read < 3 {
8278                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8279                _next_ordinal_to_read += 1;
8280                next_offset += envelope_size;
8281            }
8282
8283            let next_out_of_line = decoder.next_out_of_line();
8284            let handles_before = decoder.remaining_handles();
8285            if let Some((inlined, num_bytes, num_handles)) =
8286                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8287            {
8288                let member_inline_size =
8289                    <Nat64PacketCounters as fidl::encoding::TypeMarker>::inline_size(
8290                        decoder.context,
8291                    );
8292                if inlined != (member_inline_size <= 4) {
8293                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8294                }
8295                let inner_offset;
8296                let mut inner_depth = depth.clone();
8297                if inlined {
8298                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8299                    inner_offset = next_offset;
8300                } else {
8301                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8302                    inner_depth.increment()?;
8303                }
8304                let val_ref = self
8305                    .unsupported_protocol
8306                    .get_or_insert_with(|| fidl::new_empty!(Nat64PacketCounters, D));
8307                fidl::decode!(Nat64PacketCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8308                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8309                {
8310                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8311                }
8312                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8313                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8314                }
8315            }
8316
8317            next_offset += envelope_size;
8318            _next_ordinal_to_read += 1;
8319            if next_offset >= end_offset {
8320                return Ok(());
8321            }
8322
8323            // Decode unknown envelopes for gaps in ordinals.
8324            while _next_ordinal_to_read < 4 {
8325                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8326                _next_ordinal_to_read += 1;
8327                next_offset += envelope_size;
8328            }
8329
8330            let next_out_of_line = decoder.next_out_of_line();
8331            let handles_before = decoder.remaining_handles();
8332            if let Some((inlined, num_bytes, num_handles)) =
8333                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8334            {
8335                let member_inline_size =
8336                    <Nat64PacketCounters as fidl::encoding::TypeMarker>::inline_size(
8337                        decoder.context,
8338                    );
8339                if inlined != (member_inline_size <= 4) {
8340                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8341                }
8342                let inner_offset;
8343                let mut inner_depth = depth.clone();
8344                if inlined {
8345                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8346                    inner_offset = next_offset;
8347                } else {
8348                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8349                    inner_depth.increment()?;
8350                }
8351                let val_ref =
8352                    self.no_mapping.get_or_insert_with(|| fidl::new_empty!(Nat64PacketCounters, D));
8353                fidl::decode!(Nat64PacketCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8354                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8355                {
8356                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8357                }
8358                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8359                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8360                }
8361            }
8362
8363            next_offset += envelope_size;
8364
8365            // Decode the remaining unknown envelopes.
8366            while next_offset < end_offset {
8367                _next_ordinal_to_read += 1;
8368                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8369                next_offset += envelope_size;
8370            }
8371
8372            Ok(())
8373        }
8374    }
8375
8376    impl Nat64Info {
8377        #[inline(always)]
8378        fn max_ordinal_present(&self) -> u64 {
8379            if let Some(_) = self.nat64_protocol_counters {
8380                return 4;
8381            }
8382            if let Some(_) = self.nat64_error_counters {
8383                return 3;
8384            }
8385            if let Some(_) = self.nat64_mappings {
8386                return 2;
8387            }
8388            if let Some(_) = self.nat64_state {
8389                return 1;
8390            }
8391            0
8392        }
8393    }
8394
8395    impl fidl::encoding::ValueTypeMarker for Nat64Info {
8396        type Borrowed<'a> = &'a Self;
8397        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8398            value
8399        }
8400    }
8401
8402    unsafe impl fidl::encoding::TypeMarker for Nat64Info {
8403        type Owned = Self;
8404
8405        #[inline(always)]
8406        fn inline_align(_context: fidl::encoding::Context) -> usize {
8407            8
8408        }
8409
8410        #[inline(always)]
8411        fn inline_size(_context: fidl::encoding::Context) -> usize {
8412            16
8413        }
8414    }
8415
8416    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64Info, D>
8417        for &Nat64Info
8418    {
8419        unsafe fn encode(
8420            self,
8421            encoder: &mut fidl::encoding::Encoder<'_, D>,
8422            offset: usize,
8423            mut depth: fidl::encoding::Depth,
8424        ) -> fidl::Result<()> {
8425            encoder.debug_check_bounds::<Nat64Info>(offset);
8426            // Vector header
8427            let max_ordinal: u64 = self.max_ordinal_present();
8428            encoder.write_num(max_ordinal, offset);
8429            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8430            // Calling encoder.out_of_line_offset(0) is not allowed.
8431            if max_ordinal == 0 {
8432                return Ok(());
8433            }
8434            depth.increment()?;
8435            let envelope_size = 8;
8436            let bytes_len = max_ordinal as usize * envelope_size;
8437            #[allow(unused_variables)]
8438            let offset = encoder.out_of_line_offset(bytes_len);
8439            let mut _prev_end_offset: usize = 0;
8440            if 1 > max_ordinal {
8441                return Ok(());
8442            }
8443
8444            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8445            // are envelope_size bytes.
8446            let cur_offset: usize = (1 - 1) * envelope_size;
8447
8448            // Zero reserved fields.
8449            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8450
8451            // Safety:
8452            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8453            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8454            //   envelope_size bytes, there is always sufficient room.
8455            fidl::encoding::encode_in_envelope_optional::<BorderRoutingNat64State, D>(
8456                self.nat64_state
8457                    .as_ref()
8458                    .map(<BorderRoutingNat64State as fidl::encoding::ValueTypeMarker>::borrow),
8459                encoder,
8460                offset + cur_offset,
8461                depth,
8462            )?;
8463
8464            _prev_end_offset = cur_offset + envelope_size;
8465            if 2 > max_ordinal {
8466                return Ok(());
8467            }
8468
8469            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8470            // are envelope_size bytes.
8471            let cur_offset: usize = (2 - 1) * envelope_size;
8472
8473            // Zero reserved fields.
8474            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8475
8476            // Safety:
8477            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8478            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8479            //   envelope_size bytes, there is always sufficient room.
8480            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Nat64Mapping>, D>(
8481            self.nat64_mappings.as_ref().map(<fidl::encoding::UnboundedVector<Nat64Mapping> as fidl::encoding::ValueTypeMarker>::borrow),
8482            encoder, offset + cur_offset, depth
8483        )?;
8484
8485            _prev_end_offset = cur_offset + envelope_size;
8486            if 3 > max_ordinal {
8487                return Ok(());
8488            }
8489
8490            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8491            // are envelope_size bytes.
8492            let cur_offset: usize = (3 - 1) * envelope_size;
8493
8494            // Zero reserved fields.
8495            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8496
8497            // Safety:
8498            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8499            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8500            //   envelope_size bytes, there is always sufficient room.
8501            fidl::encoding::encode_in_envelope_optional::<Nat64ErrorCounters, D>(
8502                self.nat64_error_counters
8503                    .as_ref()
8504                    .map(<Nat64ErrorCounters as fidl::encoding::ValueTypeMarker>::borrow),
8505                encoder,
8506                offset + cur_offset,
8507                depth,
8508            )?;
8509
8510            _prev_end_offset = cur_offset + envelope_size;
8511            if 4 > max_ordinal {
8512                return Ok(());
8513            }
8514
8515            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8516            // are envelope_size bytes.
8517            let cur_offset: usize = (4 - 1) * envelope_size;
8518
8519            // Zero reserved fields.
8520            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8521
8522            // Safety:
8523            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8524            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8525            //   envelope_size bytes, there is always sufficient room.
8526            fidl::encoding::encode_in_envelope_optional::<Nat64ProtocolCounters, D>(
8527                self.nat64_protocol_counters
8528                    .as_ref()
8529                    .map(<Nat64ProtocolCounters as fidl::encoding::ValueTypeMarker>::borrow),
8530                encoder,
8531                offset + cur_offset,
8532                depth,
8533            )?;
8534
8535            _prev_end_offset = cur_offset + envelope_size;
8536
8537            Ok(())
8538        }
8539    }
8540
8541    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64Info {
8542        #[inline(always)]
8543        fn new_empty() -> Self {
8544            Self::default()
8545        }
8546
8547        unsafe fn decode(
8548            &mut self,
8549            decoder: &mut fidl::encoding::Decoder<'_, D>,
8550            offset: usize,
8551            mut depth: fidl::encoding::Depth,
8552        ) -> fidl::Result<()> {
8553            decoder.debug_check_bounds::<Self>(offset);
8554            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8555                None => return Err(fidl::Error::NotNullable),
8556                Some(len) => len,
8557            };
8558            // Calling decoder.out_of_line_offset(0) is not allowed.
8559            if len == 0 {
8560                return Ok(());
8561            };
8562            depth.increment()?;
8563            let envelope_size = 8;
8564            let bytes_len = len * envelope_size;
8565            let offset = decoder.out_of_line_offset(bytes_len)?;
8566            // Decode the envelope for each type.
8567            let mut _next_ordinal_to_read = 0;
8568            let mut next_offset = offset;
8569            let end_offset = offset + bytes_len;
8570            _next_ordinal_to_read += 1;
8571            if next_offset >= end_offset {
8572                return Ok(());
8573            }
8574
8575            // Decode unknown envelopes for gaps in ordinals.
8576            while _next_ordinal_to_read < 1 {
8577                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8578                _next_ordinal_to_read += 1;
8579                next_offset += envelope_size;
8580            }
8581
8582            let next_out_of_line = decoder.next_out_of_line();
8583            let handles_before = decoder.remaining_handles();
8584            if let Some((inlined, num_bytes, num_handles)) =
8585                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8586            {
8587                let member_inline_size =
8588                    <BorderRoutingNat64State as fidl::encoding::TypeMarker>::inline_size(
8589                        decoder.context,
8590                    );
8591                if inlined != (member_inline_size <= 4) {
8592                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8593                }
8594                let inner_offset;
8595                let mut inner_depth = depth.clone();
8596                if inlined {
8597                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8598                    inner_offset = next_offset;
8599                } else {
8600                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8601                    inner_depth.increment()?;
8602                }
8603                let val_ref = self
8604                    .nat64_state
8605                    .get_or_insert_with(|| fidl::new_empty!(BorderRoutingNat64State, D));
8606                fidl::decode!(
8607                    BorderRoutingNat64State,
8608                    D,
8609                    val_ref,
8610                    decoder,
8611                    inner_offset,
8612                    inner_depth
8613                )?;
8614                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8615                {
8616                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8617                }
8618                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8619                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8620                }
8621            }
8622
8623            next_offset += envelope_size;
8624            _next_ordinal_to_read += 1;
8625            if next_offset >= end_offset {
8626                return Ok(());
8627            }
8628
8629            // Decode unknown envelopes for gaps in ordinals.
8630            while _next_ordinal_to_read < 2 {
8631                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8632                _next_ordinal_to_read += 1;
8633                next_offset += envelope_size;
8634            }
8635
8636            let next_out_of_line = decoder.next_out_of_line();
8637            let handles_before = decoder.remaining_handles();
8638            if let Some((inlined, num_bytes, num_handles)) =
8639                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8640            {
8641                let member_inline_size = <fidl::encoding::UnboundedVector<Nat64Mapping> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8642                if inlined != (member_inline_size <= 4) {
8643                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8644                }
8645                let inner_offset;
8646                let mut inner_depth = depth.clone();
8647                if inlined {
8648                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8649                    inner_offset = next_offset;
8650                } else {
8651                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8652                    inner_depth.increment()?;
8653                }
8654                let val_ref = self.nat64_mappings.get_or_insert_with(|| {
8655                    fidl::new_empty!(fidl::encoding::UnboundedVector<Nat64Mapping>, D)
8656                });
8657                fidl::decode!(
8658                    fidl::encoding::UnboundedVector<Nat64Mapping>,
8659                    D,
8660                    val_ref,
8661                    decoder,
8662                    inner_offset,
8663                    inner_depth
8664                )?;
8665                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8666                {
8667                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8668                }
8669                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8670                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8671                }
8672            }
8673
8674            next_offset += envelope_size;
8675            _next_ordinal_to_read += 1;
8676            if next_offset >= end_offset {
8677                return Ok(());
8678            }
8679
8680            // Decode unknown envelopes for gaps in ordinals.
8681            while _next_ordinal_to_read < 3 {
8682                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8683                _next_ordinal_to_read += 1;
8684                next_offset += envelope_size;
8685            }
8686
8687            let next_out_of_line = decoder.next_out_of_line();
8688            let handles_before = decoder.remaining_handles();
8689            if let Some((inlined, num_bytes, num_handles)) =
8690                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8691            {
8692                let member_inline_size =
8693                    <Nat64ErrorCounters as fidl::encoding::TypeMarker>::inline_size(
8694                        decoder.context,
8695                    );
8696                if inlined != (member_inline_size <= 4) {
8697                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8698                }
8699                let inner_offset;
8700                let mut inner_depth = depth.clone();
8701                if inlined {
8702                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8703                    inner_offset = next_offset;
8704                } else {
8705                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8706                    inner_depth.increment()?;
8707                }
8708                let val_ref = self
8709                    .nat64_error_counters
8710                    .get_or_insert_with(|| fidl::new_empty!(Nat64ErrorCounters, D));
8711                fidl::decode!(Nat64ErrorCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8712                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8713                {
8714                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8715                }
8716                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8717                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8718                }
8719            }
8720
8721            next_offset += envelope_size;
8722            _next_ordinal_to_read += 1;
8723            if next_offset >= end_offset {
8724                return Ok(());
8725            }
8726
8727            // Decode unknown envelopes for gaps in ordinals.
8728            while _next_ordinal_to_read < 4 {
8729                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8730                _next_ordinal_to_read += 1;
8731                next_offset += envelope_size;
8732            }
8733
8734            let next_out_of_line = decoder.next_out_of_line();
8735            let handles_before = decoder.remaining_handles();
8736            if let Some((inlined, num_bytes, num_handles)) =
8737                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8738            {
8739                let member_inline_size =
8740                    <Nat64ProtocolCounters as fidl::encoding::TypeMarker>::inline_size(
8741                        decoder.context,
8742                    );
8743                if inlined != (member_inline_size <= 4) {
8744                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8745                }
8746                let inner_offset;
8747                let mut inner_depth = depth.clone();
8748                if inlined {
8749                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8750                    inner_offset = next_offset;
8751                } else {
8752                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8753                    inner_depth.increment()?;
8754                }
8755                let val_ref = self
8756                    .nat64_protocol_counters
8757                    .get_or_insert_with(|| fidl::new_empty!(Nat64ProtocolCounters, D));
8758                fidl::decode!(
8759                    Nat64ProtocolCounters,
8760                    D,
8761                    val_ref,
8762                    decoder,
8763                    inner_offset,
8764                    inner_depth
8765                )?;
8766                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8767                {
8768                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8769                }
8770                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8771                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8772                }
8773            }
8774
8775            next_offset += envelope_size;
8776
8777            // Decode the remaining unknown envelopes.
8778            while next_offset < end_offset {
8779                _next_ordinal_to_read += 1;
8780                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8781                next_offset += envelope_size;
8782            }
8783
8784            Ok(())
8785        }
8786    }
8787
8788    impl Nat64Mapping {
8789        #[inline(always)]
8790        fn max_ordinal_present(&self) -> u64 {
8791            if let Some(_) = self.counters {
8792                return 5;
8793            }
8794            if let Some(_) = self.remaining_time_ms {
8795                return 4;
8796            }
8797            if let Some(_) = self.ip6_addr {
8798                return 3;
8799            }
8800            if let Some(_) = self.ip4_addr {
8801                return 2;
8802            }
8803            if let Some(_) = self.mapping_id {
8804                return 1;
8805            }
8806            0
8807        }
8808    }
8809
8810    impl fidl::encoding::ValueTypeMarker for Nat64Mapping {
8811        type Borrowed<'a> = &'a Self;
8812        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8813            value
8814        }
8815    }
8816
8817    unsafe impl fidl::encoding::TypeMarker for Nat64Mapping {
8818        type Owned = Self;
8819
8820        #[inline(always)]
8821        fn inline_align(_context: fidl::encoding::Context) -> usize {
8822            8
8823        }
8824
8825        #[inline(always)]
8826        fn inline_size(_context: fidl::encoding::Context) -> usize {
8827            16
8828        }
8829    }
8830
8831    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64Mapping, D>
8832        for &Nat64Mapping
8833    {
8834        unsafe fn encode(
8835            self,
8836            encoder: &mut fidl::encoding::Encoder<'_, D>,
8837            offset: usize,
8838            mut depth: fidl::encoding::Depth,
8839        ) -> fidl::Result<()> {
8840            encoder.debug_check_bounds::<Nat64Mapping>(offset);
8841            // Vector header
8842            let max_ordinal: u64 = self.max_ordinal_present();
8843            encoder.write_num(max_ordinal, offset);
8844            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8845            // Calling encoder.out_of_line_offset(0) is not allowed.
8846            if max_ordinal == 0 {
8847                return Ok(());
8848            }
8849            depth.increment()?;
8850            let envelope_size = 8;
8851            let bytes_len = max_ordinal as usize * envelope_size;
8852            #[allow(unused_variables)]
8853            let offset = encoder.out_of_line_offset(bytes_len);
8854            let mut _prev_end_offset: usize = 0;
8855            if 1 > max_ordinal {
8856                return Ok(());
8857            }
8858
8859            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8860            // are envelope_size bytes.
8861            let cur_offset: usize = (1 - 1) * envelope_size;
8862
8863            // Zero reserved fields.
8864            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8865
8866            // Safety:
8867            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8868            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8869            //   envelope_size bytes, there is always sufficient room.
8870            fidl::encoding::encode_in_envelope_optional::<u64, D>(
8871                self.mapping_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
8872                encoder,
8873                offset + cur_offset,
8874                depth,
8875            )?;
8876
8877            _prev_end_offset = cur_offset + envelope_size;
8878            if 2 > max_ordinal {
8879                return Ok(());
8880            }
8881
8882            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8883            // are envelope_size bytes.
8884            let cur_offset: usize = (2 - 1) * envelope_size;
8885
8886            // Zero reserved fields.
8887            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8888
8889            // Safety:
8890            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8891            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8892            //   envelope_size bytes, there is always sufficient room.
8893            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8894            self.ip4_addr.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8895            encoder, offset + cur_offset, depth
8896        )?;
8897
8898            _prev_end_offset = cur_offset + envelope_size;
8899            if 3 > max_ordinal {
8900                return Ok(());
8901            }
8902
8903            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8904            // are envelope_size bytes.
8905            let cur_offset: usize = (3 - 1) * envelope_size;
8906
8907            // Zero reserved fields.
8908            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8909
8910            // Safety:
8911            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8912            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8913            //   envelope_size bytes, there is always sufficient room.
8914            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8915            self.ip6_addr.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8916            encoder, offset + cur_offset, depth
8917        )?;
8918
8919            _prev_end_offset = cur_offset + envelope_size;
8920            if 4 > max_ordinal {
8921                return Ok(());
8922            }
8923
8924            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8925            // are envelope_size bytes.
8926            let cur_offset: usize = (4 - 1) * envelope_size;
8927
8928            // Zero reserved fields.
8929            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8930
8931            // Safety:
8932            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8933            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8934            //   envelope_size bytes, there is always sufficient room.
8935            fidl::encoding::encode_in_envelope_optional::<u32, D>(
8936                self.remaining_time_ms
8937                    .as_ref()
8938                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
8939                encoder,
8940                offset + cur_offset,
8941                depth,
8942            )?;
8943
8944            _prev_end_offset = cur_offset + envelope_size;
8945            if 5 > max_ordinal {
8946                return Ok(());
8947            }
8948
8949            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8950            // are envelope_size bytes.
8951            let cur_offset: usize = (5 - 1) * envelope_size;
8952
8953            // Zero reserved fields.
8954            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8955
8956            // Safety:
8957            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8958            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8959            //   envelope_size bytes, there is always sufficient room.
8960            fidl::encoding::encode_in_envelope_optional::<Nat64ProtocolCounters, D>(
8961                self.counters
8962                    .as_ref()
8963                    .map(<Nat64ProtocolCounters as fidl::encoding::ValueTypeMarker>::borrow),
8964                encoder,
8965                offset + cur_offset,
8966                depth,
8967            )?;
8968
8969            _prev_end_offset = cur_offset + envelope_size;
8970
8971            Ok(())
8972        }
8973    }
8974
8975    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64Mapping {
8976        #[inline(always)]
8977        fn new_empty() -> Self {
8978            Self::default()
8979        }
8980
8981        unsafe fn decode(
8982            &mut self,
8983            decoder: &mut fidl::encoding::Decoder<'_, D>,
8984            offset: usize,
8985            mut depth: fidl::encoding::Depth,
8986        ) -> fidl::Result<()> {
8987            decoder.debug_check_bounds::<Self>(offset);
8988            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8989                None => return Err(fidl::Error::NotNullable),
8990                Some(len) => len,
8991            };
8992            // Calling decoder.out_of_line_offset(0) is not allowed.
8993            if len == 0 {
8994                return Ok(());
8995            };
8996            depth.increment()?;
8997            let envelope_size = 8;
8998            let bytes_len = len * envelope_size;
8999            let offset = decoder.out_of_line_offset(bytes_len)?;
9000            // Decode the envelope for each type.
9001            let mut _next_ordinal_to_read = 0;
9002            let mut next_offset = offset;
9003            let end_offset = offset + bytes_len;
9004            _next_ordinal_to_read += 1;
9005            if next_offset >= end_offset {
9006                return Ok(());
9007            }
9008
9009            // Decode unknown envelopes for gaps in ordinals.
9010            while _next_ordinal_to_read < 1 {
9011                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9012                _next_ordinal_to_read += 1;
9013                next_offset += envelope_size;
9014            }
9015
9016            let next_out_of_line = decoder.next_out_of_line();
9017            let handles_before = decoder.remaining_handles();
9018            if let Some((inlined, num_bytes, num_handles)) =
9019                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9020            {
9021                let member_inline_size =
9022                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9023                if inlined != (member_inline_size <= 4) {
9024                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9025                }
9026                let inner_offset;
9027                let mut inner_depth = depth.clone();
9028                if inlined {
9029                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9030                    inner_offset = next_offset;
9031                } else {
9032                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9033                    inner_depth.increment()?;
9034                }
9035                let val_ref = self.mapping_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
9036                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9037                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9038                {
9039                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9040                }
9041                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9042                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9043                }
9044            }
9045
9046            next_offset += envelope_size;
9047            _next_ordinal_to_read += 1;
9048            if next_offset >= end_offset {
9049                return Ok(());
9050            }
9051
9052            // Decode unknown envelopes for gaps in ordinals.
9053            while _next_ordinal_to_read < 2 {
9054                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9055                _next_ordinal_to_read += 1;
9056                next_offset += envelope_size;
9057            }
9058
9059            let next_out_of_line = decoder.next_out_of_line();
9060            let handles_before = decoder.remaining_handles();
9061            if let Some((inlined, num_bytes, num_handles)) =
9062                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9063            {
9064                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9065                if inlined != (member_inline_size <= 4) {
9066                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9067                }
9068                let inner_offset;
9069                let mut inner_depth = depth.clone();
9070                if inlined {
9071                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9072                    inner_offset = next_offset;
9073                } else {
9074                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9075                    inner_depth.increment()?;
9076                }
9077                let val_ref = self.ip4_addr.get_or_insert_with(|| {
9078                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
9079                });
9080                fidl::decode!(
9081                    fidl::encoding::UnboundedVector<u8>,
9082                    D,
9083                    val_ref,
9084                    decoder,
9085                    inner_offset,
9086                    inner_depth
9087                )?;
9088                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9089                {
9090                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9091                }
9092                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9093                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9094                }
9095            }
9096
9097            next_offset += envelope_size;
9098            _next_ordinal_to_read += 1;
9099            if next_offset >= end_offset {
9100                return Ok(());
9101            }
9102
9103            // Decode unknown envelopes for gaps in ordinals.
9104            while _next_ordinal_to_read < 3 {
9105                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9106                _next_ordinal_to_read += 1;
9107                next_offset += envelope_size;
9108            }
9109
9110            let next_out_of_line = decoder.next_out_of_line();
9111            let handles_before = decoder.remaining_handles();
9112            if let Some((inlined, num_bytes, num_handles)) =
9113                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9114            {
9115                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9116                if inlined != (member_inline_size <= 4) {
9117                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9118                }
9119                let inner_offset;
9120                let mut inner_depth = depth.clone();
9121                if inlined {
9122                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9123                    inner_offset = next_offset;
9124                } else {
9125                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9126                    inner_depth.increment()?;
9127                }
9128                let val_ref = self.ip6_addr.get_or_insert_with(|| {
9129                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
9130                });
9131                fidl::decode!(
9132                    fidl::encoding::UnboundedVector<u8>,
9133                    D,
9134                    val_ref,
9135                    decoder,
9136                    inner_offset,
9137                    inner_depth
9138                )?;
9139                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9140                {
9141                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9142                }
9143                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9144                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9145                }
9146            }
9147
9148            next_offset += envelope_size;
9149            _next_ordinal_to_read += 1;
9150            if next_offset >= end_offset {
9151                return Ok(());
9152            }
9153
9154            // Decode unknown envelopes for gaps in ordinals.
9155            while _next_ordinal_to_read < 4 {
9156                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9157                _next_ordinal_to_read += 1;
9158                next_offset += envelope_size;
9159            }
9160
9161            let next_out_of_line = decoder.next_out_of_line();
9162            let handles_before = decoder.remaining_handles();
9163            if let Some((inlined, num_bytes, num_handles)) =
9164                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9165            {
9166                let member_inline_size =
9167                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9168                if inlined != (member_inline_size <= 4) {
9169                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9170                }
9171                let inner_offset;
9172                let mut inner_depth = depth.clone();
9173                if inlined {
9174                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9175                    inner_offset = next_offset;
9176                } else {
9177                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9178                    inner_depth.increment()?;
9179                }
9180                let val_ref =
9181                    self.remaining_time_ms.get_or_insert_with(|| fidl::new_empty!(u32, D));
9182                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
9183                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9184                {
9185                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9186                }
9187                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9188                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9189                }
9190            }
9191
9192            next_offset += envelope_size;
9193            _next_ordinal_to_read += 1;
9194            if next_offset >= end_offset {
9195                return Ok(());
9196            }
9197
9198            // Decode unknown envelopes for gaps in ordinals.
9199            while _next_ordinal_to_read < 5 {
9200                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9201                _next_ordinal_to_read += 1;
9202                next_offset += envelope_size;
9203            }
9204
9205            let next_out_of_line = decoder.next_out_of_line();
9206            let handles_before = decoder.remaining_handles();
9207            if let Some((inlined, num_bytes, num_handles)) =
9208                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9209            {
9210                let member_inline_size =
9211                    <Nat64ProtocolCounters as fidl::encoding::TypeMarker>::inline_size(
9212                        decoder.context,
9213                    );
9214                if inlined != (member_inline_size <= 4) {
9215                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9216                }
9217                let inner_offset;
9218                let mut inner_depth = depth.clone();
9219                if inlined {
9220                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9221                    inner_offset = next_offset;
9222                } else {
9223                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9224                    inner_depth.increment()?;
9225                }
9226                let val_ref =
9227                    self.counters.get_or_insert_with(|| fidl::new_empty!(Nat64ProtocolCounters, D));
9228                fidl::decode!(
9229                    Nat64ProtocolCounters,
9230                    D,
9231                    val_ref,
9232                    decoder,
9233                    inner_offset,
9234                    inner_depth
9235                )?;
9236                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9237                {
9238                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9239                }
9240                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9241                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9242                }
9243            }
9244
9245            next_offset += envelope_size;
9246
9247            // Decode the remaining unknown envelopes.
9248            while next_offset < end_offset {
9249                _next_ordinal_to_read += 1;
9250                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9251                next_offset += envelope_size;
9252            }
9253
9254            Ok(())
9255        }
9256    }
9257
9258    impl Nat64PacketCounters {
9259        #[inline(always)]
9260        fn max_ordinal_present(&self) -> u64 {
9261            if let Some(_) = self.ipv6_to_ipv4_packets {
9262                return 2;
9263            }
9264            if let Some(_) = self.ipv4_to_ipv6_packets {
9265                return 1;
9266            }
9267            0
9268        }
9269    }
9270
9271    impl fidl::encoding::ValueTypeMarker for Nat64PacketCounters {
9272        type Borrowed<'a> = &'a Self;
9273        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9274            value
9275        }
9276    }
9277
9278    unsafe impl fidl::encoding::TypeMarker for Nat64PacketCounters {
9279        type Owned = Self;
9280
9281        #[inline(always)]
9282        fn inline_align(_context: fidl::encoding::Context) -> usize {
9283            8
9284        }
9285
9286        #[inline(always)]
9287        fn inline_size(_context: fidl::encoding::Context) -> usize {
9288            16
9289        }
9290    }
9291
9292    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64PacketCounters, D>
9293        for &Nat64PacketCounters
9294    {
9295        unsafe fn encode(
9296            self,
9297            encoder: &mut fidl::encoding::Encoder<'_, D>,
9298            offset: usize,
9299            mut depth: fidl::encoding::Depth,
9300        ) -> fidl::Result<()> {
9301            encoder.debug_check_bounds::<Nat64PacketCounters>(offset);
9302            // Vector header
9303            let max_ordinal: u64 = self.max_ordinal_present();
9304            encoder.write_num(max_ordinal, offset);
9305            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9306            // Calling encoder.out_of_line_offset(0) is not allowed.
9307            if max_ordinal == 0 {
9308                return Ok(());
9309            }
9310            depth.increment()?;
9311            let envelope_size = 8;
9312            let bytes_len = max_ordinal as usize * envelope_size;
9313            #[allow(unused_variables)]
9314            let offset = encoder.out_of_line_offset(bytes_len);
9315            let mut _prev_end_offset: usize = 0;
9316            if 1 > max_ordinal {
9317                return Ok(());
9318            }
9319
9320            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9321            // are envelope_size bytes.
9322            let cur_offset: usize = (1 - 1) * envelope_size;
9323
9324            // Zero reserved fields.
9325            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9326
9327            // Safety:
9328            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9329            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9330            //   envelope_size bytes, there is always sufficient room.
9331            fidl::encoding::encode_in_envelope_optional::<u64, D>(
9332                self.ipv4_to_ipv6_packets
9333                    .as_ref()
9334                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9335                encoder,
9336                offset + cur_offset,
9337                depth,
9338            )?;
9339
9340            _prev_end_offset = cur_offset + envelope_size;
9341            if 2 > max_ordinal {
9342                return Ok(());
9343            }
9344
9345            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9346            // are envelope_size bytes.
9347            let cur_offset: usize = (2 - 1) * envelope_size;
9348
9349            // Zero reserved fields.
9350            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9351
9352            // Safety:
9353            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9354            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9355            //   envelope_size bytes, there is always sufficient room.
9356            fidl::encoding::encode_in_envelope_optional::<u64, D>(
9357                self.ipv6_to_ipv4_packets
9358                    .as_ref()
9359                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9360                encoder,
9361                offset + cur_offset,
9362                depth,
9363            )?;
9364
9365            _prev_end_offset = cur_offset + envelope_size;
9366
9367            Ok(())
9368        }
9369    }
9370
9371    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64PacketCounters {
9372        #[inline(always)]
9373        fn new_empty() -> Self {
9374            Self::default()
9375        }
9376
9377        unsafe fn decode(
9378            &mut self,
9379            decoder: &mut fidl::encoding::Decoder<'_, D>,
9380            offset: usize,
9381            mut depth: fidl::encoding::Depth,
9382        ) -> fidl::Result<()> {
9383            decoder.debug_check_bounds::<Self>(offset);
9384            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9385                None => return Err(fidl::Error::NotNullable),
9386                Some(len) => len,
9387            };
9388            // Calling decoder.out_of_line_offset(0) is not allowed.
9389            if len == 0 {
9390                return Ok(());
9391            };
9392            depth.increment()?;
9393            let envelope_size = 8;
9394            let bytes_len = len * envelope_size;
9395            let offset = decoder.out_of_line_offset(bytes_len)?;
9396            // Decode the envelope for each type.
9397            let mut _next_ordinal_to_read = 0;
9398            let mut next_offset = offset;
9399            let end_offset = offset + bytes_len;
9400            _next_ordinal_to_read += 1;
9401            if next_offset >= end_offset {
9402                return Ok(());
9403            }
9404
9405            // Decode unknown envelopes for gaps in ordinals.
9406            while _next_ordinal_to_read < 1 {
9407                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9408                _next_ordinal_to_read += 1;
9409                next_offset += envelope_size;
9410            }
9411
9412            let next_out_of_line = decoder.next_out_of_line();
9413            let handles_before = decoder.remaining_handles();
9414            if let Some((inlined, num_bytes, num_handles)) =
9415                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9416            {
9417                let member_inline_size =
9418                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9419                if inlined != (member_inline_size <= 4) {
9420                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9421                }
9422                let inner_offset;
9423                let mut inner_depth = depth.clone();
9424                if inlined {
9425                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9426                    inner_offset = next_offset;
9427                } else {
9428                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9429                    inner_depth.increment()?;
9430                }
9431                let val_ref =
9432                    self.ipv4_to_ipv6_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
9433                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9434                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9435                {
9436                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9437                }
9438                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9439                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9440                }
9441            }
9442
9443            next_offset += envelope_size;
9444            _next_ordinal_to_read += 1;
9445            if next_offset >= end_offset {
9446                return Ok(());
9447            }
9448
9449            // Decode unknown envelopes for gaps in ordinals.
9450            while _next_ordinal_to_read < 2 {
9451                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9452                _next_ordinal_to_read += 1;
9453                next_offset += envelope_size;
9454            }
9455
9456            let next_out_of_line = decoder.next_out_of_line();
9457            let handles_before = decoder.remaining_handles();
9458            if let Some((inlined, num_bytes, num_handles)) =
9459                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9460            {
9461                let member_inline_size =
9462                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9463                if inlined != (member_inline_size <= 4) {
9464                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9465                }
9466                let inner_offset;
9467                let mut inner_depth = depth.clone();
9468                if inlined {
9469                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9470                    inner_offset = next_offset;
9471                } else {
9472                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9473                    inner_depth.increment()?;
9474                }
9475                let val_ref =
9476                    self.ipv6_to_ipv4_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
9477                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9478                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9479                {
9480                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9481                }
9482                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9483                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9484                }
9485            }
9486
9487            next_offset += envelope_size;
9488
9489            // Decode the remaining unknown envelopes.
9490            while next_offset < end_offset {
9491                _next_ordinal_to_read += 1;
9492                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9493                next_offset += envelope_size;
9494            }
9495
9496            Ok(())
9497        }
9498    }
9499
9500    impl Nat64ProtocolCounters {
9501        #[inline(always)]
9502        fn max_ordinal_present(&self) -> u64 {
9503            if let Some(_) = self.total {
9504                return 4;
9505            }
9506            if let Some(_) = self.icmp {
9507                return 3;
9508            }
9509            if let Some(_) = self.udp {
9510                return 2;
9511            }
9512            if let Some(_) = self.tcp {
9513                return 1;
9514            }
9515            0
9516        }
9517    }
9518
9519    impl fidl::encoding::ValueTypeMarker for Nat64ProtocolCounters {
9520        type Borrowed<'a> = &'a Self;
9521        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9522            value
9523        }
9524    }
9525
9526    unsafe impl fidl::encoding::TypeMarker for Nat64ProtocolCounters {
9527        type Owned = Self;
9528
9529        #[inline(always)]
9530        fn inline_align(_context: fidl::encoding::Context) -> usize {
9531            8
9532        }
9533
9534        #[inline(always)]
9535        fn inline_size(_context: fidl::encoding::Context) -> usize {
9536            16
9537        }
9538    }
9539
9540    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64ProtocolCounters, D>
9541        for &Nat64ProtocolCounters
9542    {
9543        unsafe fn encode(
9544            self,
9545            encoder: &mut fidl::encoding::Encoder<'_, D>,
9546            offset: usize,
9547            mut depth: fidl::encoding::Depth,
9548        ) -> fidl::Result<()> {
9549            encoder.debug_check_bounds::<Nat64ProtocolCounters>(offset);
9550            // Vector header
9551            let max_ordinal: u64 = self.max_ordinal_present();
9552            encoder.write_num(max_ordinal, offset);
9553            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9554            // Calling encoder.out_of_line_offset(0) is not allowed.
9555            if max_ordinal == 0 {
9556                return Ok(());
9557            }
9558            depth.increment()?;
9559            let envelope_size = 8;
9560            let bytes_len = max_ordinal as usize * envelope_size;
9561            #[allow(unused_variables)]
9562            let offset = encoder.out_of_line_offset(bytes_len);
9563            let mut _prev_end_offset: usize = 0;
9564            if 1 > max_ordinal {
9565                return Ok(());
9566            }
9567
9568            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9569            // are envelope_size bytes.
9570            let cur_offset: usize = (1 - 1) * envelope_size;
9571
9572            // Zero reserved fields.
9573            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9574
9575            // Safety:
9576            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9577            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9578            //   envelope_size bytes, there is always sufficient room.
9579            fidl::encoding::encode_in_envelope_optional::<Nat64TrafficCounters, D>(
9580                self.tcp
9581                    .as_ref()
9582                    .map(<Nat64TrafficCounters as fidl::encoding::ValueTypeMarker>::borrow),
9583                encoder,
9584                offset + cur_offset,
9585                depth,
9586            )?;
9587
9588            _prev_end_offset = cur_offset + envelope_size;
9589            if 2 > max_ordinal {
9590                return Ok(());
9591            }
9592
9593            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9594            // are envelope_size bytes.
9595            let cur_offset: usize = (2 - 1) * envelope_size;
9596
9597            // Zero reserved fields.
9598            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9599
9600            // Safety:
9601            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9602            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9603            //   envelope_size bytes, there is always sufficient room.
9604            fidl::encoding::encode_in_envelope_optional::<Nat64TrafficCounters, D>(
9605                self.udp
9606                    .as_ref()
9607                    .map(<Nat64TrafficCounters as fidl::encoding::ValueTypeMarker>::borrow),
9608                encoder,
9609                offset + cur_offset,
9610                depth,
9611            )?;
9612
9613            _prev_end_offset = cur_offset + envelope_size;
9614            if 3 > max_ordinal {
9615                return Ok(());
9616            }
9617
9618            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9619            // are envelope_size bytes.
9620            let cur_offset: usize = (3 - 1) * envelope_size;
9621
9622            // Zero reserved fields.
9623            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9624
9625            // Safety:
9626            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9627            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9628            //   envelope_size bytes, there is always sufficient room.
9629            fidl::encoding::encode_in_envelope_optional::<Nat64TrafficCounters, D>(
9630                self.icmp
9631                    .as_ref()
9632                    .map(<Nat64TrafficCounters as fidl::encoding::ValueTypeMarker>::borrow),
9633                encoder,
9634                offset + cur_offset,
9635                depth,
9636            )?;
9637
9638            _prev_end_offset = cur_offset + envelope_size;
9639            if 4 > max_ordinal {
9640                return Ok(());
9641            }
9642
9643            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9644            // are envelope_size bytes.
9645            let cur_offset: usize = (4 - 1) * envelope_size;
9646
9647            // Zero reserved fields.
9648            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9649
9650            // Safety:
9651            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9652            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9653            //   envelope_size bytes, there is always sufficient room.
9654            fidl::encoding::encode_in_envelope_optional::<Nat64TrafficCounters, D>(
9655                self.total
9656                    .as_ref()
9657                    .map(<Nat64TrafficCounters as fidl::encoding::ValueTypeMarker>::borrow),
9658                encoder,
9659                offset + cur_offset,
9660                depth,
9661            )?;
9662
9663            _prev_end_offset = cur_offset + envelope_size;
9664
9665            Ok(())
9666        }
9667    }
9668
9669    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64ProtocolCounters {
9670        #[inline(always)]
9671        fn new_empty() -> Self {
9672            Self::default()
9673        }
9674
9675        unsafe fn decode(
9676            &mut self,
9677            decoder: &mut fidl::encoding::Decoder<'_, D>,
9678            offset: usize,
9679            mut depth: fidl::encoding::Depth,
9680        ) -> fidl::Result<()> {
9681            decoder.debug_check_bounds::<Self>(offset);
9682            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9683                None => return Err(fidl::Error::NotNullable),
9684                Some(len) => len,
9685            };
9686            // Calling decoder.out_of_line_offset(0) is not allowed.
9687            if len == 0 {
9688                return Ok(());
9689            };
9690            depth.increment()?;
9691            let envelope_size = 8;
9692            let bytes_len = len * envelope_size;
9693            let offset = decoder.out_of_line_offset(bytes_len)?;
9694            // Decode the envelope for each type.
9695            let mut _next_ordinal_to_read = 0;
9696            let mut next_offset = offset;
9697            let end_offset = offset + bytes_len;
9698            _next_ordinal_to_read += 1;
9699            if next_offset >= end_offset {
9700                return Ok(());
9701            }
9702
9703            // Decode unknown envelopes for gaps in ordinals.
9704            while _next_ordinal_to_read < 1 {
9705                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9706                _next_ordinal_to_read += 1;
9707                next_offset += envelope_size;
9708            }
9709
9710            let next_out_of_line = decoder.next_out_of_line();
9711            let handles_before = decoder.remaining_handles();
9712            if let Some((inlined, num_bytes, num_handles)) =
9713                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9714            {
9715                let member_inline_size =
9716                    <Nat64TrafficCounters as fidl::encoding::TypeMarker>::inline_size(
9717                        decoder.context,
9718                    );
9719                if inlined != (member_inline_size <= 4) {
9720                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9721                }
9722                let inner_offset;
9723                let mut inner_depth = depth.clone();
9724                if inlined {
9725                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9726                    inner_offset = next_offset;
9727                } else {
9728                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9729                    inner_depth.increment()?;
9730                }
9731                let val_ref =
9732                    self.tcp.get_or_insert_with(|| fidl::new_empty!(Nat64TrafficCounters, D));
9733                fidl::decode!(
9734                    Nat64TrafficCounters,
9735                    D,
9736                    val_ref,
9737                    decoder,
9738                    inner_offset,
9739                    inner_depth
9740                )?;
9741                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9742                {
9743                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9744                }
9745                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9746                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9747                }
9748            }
9749
9750            next_offset += envelope_size;
9751            _next_ordinal_to_read += 1;
9752            if next_offset >= end_offset {
9753                return Ok(());
9754            }
9755
9756            // Decode unknown envelopes for gaps in ordinals.
9757            while _next_ordinal_to_read < 2 {
9758                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9759                _next_ordinal_to_read += 1;
9760                next_offset += envelope_size;
9761            }
9762
9763            let next_out_of_line = decoder.next_out_of_line();
9764            let handles_before = decoder.remaining_handles();
9765            if let Some((inlined, num_bytes, num_handles)) =
9766                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9767            {
9768                let member_inline_size =
9769                    <Nat64TrafficCounters as fidl::encoding::TypeMarker>::inline_size(
9770                        decoder.context,
9771                    );
9772                if inlined != (member_inline_size <= 4) {
9773                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9774                }
9775                let inner_offset;
9776                let mut inner_depth = depth.clone();
9777                if inlined {
9778                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9779                    inner_offset = next_offset;
9780                } else {
9781                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9782                    inner_depth.increment()?;
9783                }
9784                let val_ref =
9785                    self.udp.get_or_insert_with(|| fidl::new_empty!(Nat64TrafficCounters, D));
9786                fidl::decode!(
9787                    Nat64TrafficCounters,
9788                    D,
9789                    val_ref,
9790                    decoder,
9791                    inner_offset,
9792                    inner_depth
9793                )?;
9794                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9795                {
9796                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9797                }
9798                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9799                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9800                }
9801            }
9802
9803            next_offset += envelope_size;
9804            _next_ordinal_to_read += 1;
9805            if next_offset >= end_offset {
9806                return Ok(());
9807            }
9808
9809            // Decode unknown envelopes for gaps in ordinals.
9810            while _next_ordinal_to_read < 3 {
9811                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9812                _next_ordinal_to_read += 1;
9813                next_offset += envelope_size;
9814            }
9815
9816            let next_out_of_line = decoder.next_out_of_line();
9817            let handles_before = decoder.remaining_handles();
9818            if let Some((inlined, num_bytes, num_handles)) =
9819                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9820            {
9821                let member_inline_size =
9822                    <Nat64TrafficCounters as fidl::encoding::TypeMarker>::inline_size(
9823                        decoder.context,
9824                    );
9825                if inlined != (member_inline_size <= 4) {
9826                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9827                }
9828                let inner_offset;
9829                let mut inner_depth = depth.clone();
9830                if inlined {
9831                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9832                    inner_offset = next_offset;
9833                } else {
9834                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9835                    inner_depth.increment()?;
9836                }
9837                let val_ref =
9838                    self.icmp.get_or_insert_with(|| fidl::new_empty!(Nat64TrafficCounters, D));
9839                fidl::decode!(
9840                    Nat64TrafficCounters,
9841                    D,
9842                    val_ref,
9843                    decoder,
9844                    inner_offset,
9845                    inner_depth
9846                )?;
9847                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9848                {
9849                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9850                }
9851                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9852                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9853                }
9854            }
9855
9856            next_offset += envelope_size;
9857            _next_ordinal_to_read += 1;
9858            if next_offset >= end_offset {
9859                return Ok(());
9860            }
9861
9862            // Decode unknown envelopes for gaps in ordinals.
9863            while _next_ordinal_to_read < 4 {
9864                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9865                _next_ordinal_to_read += 1;
9866                next_offset += envelope_size;
9867            }
9868
9869            let next_out_of_line = decoder.next_out_of_line();
9870            let handles_before = decoder.remaining_handles();
9871            if let Some((inlined, num_bytes, num_handles)) =
9872                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9873            {
9874                let member_inline_size =
9875                    <Nat64TrafficCounters as fidl::encoding::TypeMarker>::inline_size(
9876                        decoder.context,
9877                    );
9878                if inlined != (member_inline_size <= 4) {
9879                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9880                }
9881                let inner_offset;
9882                let mut inner_depth = depth.clone();
9883                if inlined {
9884                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9885                    inner_offset = next_offset;
9886                } else {
9887                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9888                    inner_depth.increment()?;
9889                }
9890                let val_ref =
9891                    self.total.get_or_insert_with(|| fidl::new_empty!(Nat64TrafficCounters, D));
9892                fidl::decode!(
9893                    Nat64TrafficCounters,
9894                    D,
9895                    val_ref,
9896                    decoder,
9897                    inner_offset,
9898                    inner_depth
9899                )?;
9900                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9901                {
9902                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9903                }
9904                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9905                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9906                }
9907            }
9908
9909            next_offset += envelope_size;
9910
9911            // Decode the remaining unknown envelopes.
9912            while next_offset < end_offset {
9913                _next_ordinal_to_read += 1;
9914                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9915                next_offset += envelope_size;
9916            }
9917
9918            Ok(())
9919        }
9920    }
9921
9922    impl Nat64TrafficCounters {
9923        #[inline(always)]
9924        fn max_ordinal_present(&self) -> u64 {
9925            if let Some(_) = self.ipv6_to_ipv4_bytes {
9926                return 4;
9927            }
9928            if let Some(_) = self.ipv6_to_ipv4_packets {
9929                return 3;
9930            }
9931            if let Some(_) = self.ipv4_to_ipv6_bytes {
9932                return 2;
9933            }
9934            if let Some(_) = self.ipv4_to_ipv6_packets {
9935                return 1;
9936            }
9937            0
9938        }
9939    }
9940
9941    impl fidl::encoding::ValueTypeMarker for Nat64TrafficCounters {
9942        type Borrowed<'a> = &'a Self;
9943        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9944            value
9945        }
9946    }
9947
9948    unsafe impl fidl::encoding::TypeMarker for Nat64TrafficCounters {
9949        type Owned = Self;
9950
9951        #[inline(always)]
9952        fn inline_align(_context: fidl::encoding::Context) -> usize {
9953            8
9954        }
9955
9956        #[inline(always)]
9957        fn inline_size(_context: fidl::encoding::Context) -> usize {
9958            16
9959        }
9960    }
9961
9962    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64TrafficCounters, D>
9963        for &Nat64TrafficCounters
9964    {
9965        unsafe fn encode(
9966            self,
9967            encoder: &mut fidl::encoding::Encoder<'_, D>,
9968            offset: usize,
9969            mut depth: fidl::encoding::Depth,
9970        ) -> fidl::Result<()> {
9971            encoder.debug_check_bounds::<Nat64TrafficCounters>(offset);
9972            // Vector header
9973            let max_ordinal: u64 = self.max_ordinal_present();
9974            encoder.write_num(max_ordinal, offset);
9975            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9976            // Calling encoder.out_of_line_offset(0) is not allowed.
9977            if max_ordinal == 0 {
9978                return Ok(());
9979            }
9980            depth.increment()?;
9981            let envelope_size = 8;
9982            let bytes_len = max_ordinal as usize * envelope_size;
9983            #[allow(unused_variables)]
9984            let offset = encoder.out_of_line_offset(bytes_len);
9985            let mut _prev_end_offset: usize = 0;
9986            if 1 > max_ordinal {
9987                return Ok(());
9988            }
9989
9990            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9991            // are envelope_size bytes.
9992            let cur_offset: usize = (1 - 1) * envelope_size;
9993
9994            // Zero reserved fields.
9995            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9996
9997            // Safety:
9998            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9999            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10000            //   envelope_size bytes, there is always sufficient room.
10001            fidl::encoding::encode_in_envelope_optional::<u64, D>(
10002                self.ipv4_to_ipv6_packets
10003                    .as_ref()
10004                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10005                encoder,
10006                offset + cur_offset,
10007                depth,
10008            )?;
10009
10010            _prev_end_offset = cur_offset + envelope_size;
10011            if 2 > max_ordinal {
10012                return Ok(());
10013            }
10014
10015            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10016            // are envelope_size bytes.
10017            let cur_offset: usize = (2 - 1) * envelope_size;
10018
10019            // Zero reserved fields.
10020            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10021
10022            // Safety:
10023            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10024            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10025            //   envelope_size bytes, there is always sufficient room.
10026            fidl::encoding::encode_in_envelope_optional::<u64, D>(
10027                self.ipv4_to_ipv6_bytes
10028                    .as_ref()
10029                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10030                encoder,
10031                offset + cur_offset,
10032                depth,
10033            )?;
10034
10035            _prev_end_offset = cur_offset + envelope_size;
10036            if 3 > max_ordinal {
10037                return Ok(());
10038            }
10039
10040            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10041            // are envelope_size bytes.
10042            let cur_offset: usize = (3 - 1) * envelope_size;
10043
10044            // Zero reserved fields.
10045            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10046
10047            // Safety:
10048            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10049            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10050            //   envelope_size bytes, there is always sufficient room.
10051            fidl::encoding::encode_in_envelope_optional::<u64, D>(
10052                self.ipv6_to_ipv4_packets
10053                    .as_ref()
10054                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10055                encoder,
10056                offset + cur_offset,
10057                depth,
10058            )?;
10059
10060            _prev_end_offset = cur_offset + envelope_size;
10061            if 4 > max_ordinal {
10062                return Ok(());
10063            }
10064
10065            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10066            // are envelope_size bytes.
10067            let cur_offset: usize = (4 - 1) * envelope_size;
10068
10069            // Zero reserved fields.
10070            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10071
10072            // Safety:
10073            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10074            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10075            //   envelope_size bytes, there is always sufficient room.
10076            fidl::encoding::encode_in_envelope_optional::<u64, D>(
10077                self.ipv6_to_ipv4_bytes
10078                    .as_ref()
10079                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10080                encoder,
10081                offset + cur_offset,
10082                depth,
10083            )?;
10084
10085            _prev_end_offset = cur_offset + envelope_size;
10086
10087            Ok(())
10088        }
10089    }
10090
10091    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64TrafficCounters {
10092        #[inline(always)]
10093        fn new_empty() -> Self {
10094            Self::default()
10095        }
10096
10097        unsafe fn decode(
10098            &mut self,
10099            decoder: &mut fidl::encoding::Decoder<'_, D>,
10100            offset: usize,
10101            mut depth: fidl::encoding::Depth,
10102        ) -> fidl::Result<()> {
10103            decoder.debug_check_bounds::<Self>(offset);
10104            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10105                None => return Err(fidl::Error::NotNullable),
10106                Some(len) => len,
10107            };
10108            // Calling decoder.out_of_line_offset(0) is not allowed.
10109            if len == 0 {
10110                return Ok(());
10111            };
10112            depth.increment()?;
10113            let envelope_size = 8;
10114            let bytes_len = len * envelope_size;
10115            let offset = decoder.out_of_line_offset(bytes_len)?;
10116            // Decode the envelope for each type.
10117            let mut _next_ordinal_to_read = 0;
10118            let mut next_offset = offset;
10119            let end_offset = offset + bytes_len;
10120            _next_ordinal_to_read += 1;
10121            if next_offset >= end_offset {
10122                return Ok(());
10123            }
10124
10125            // Decode unknown envelopes for gaps in ordinals.
10126            while _next_ordinal_to_read < 1 {
10127                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10128                _next_ordinal_to_read += 1;
10129                next_offset += envelope_size;
10130            }
10131
10132            let next_out_of_line = decoder.next_out_of_line();
10133            let handles_before = decoder.remaining_handles();
10134            if let Some((inlined, num_bytes, num_handles)) =
10135                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10136            {
10137                let member_inline_size =
10138                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10139                if inlined != (member_inline_size <= 4) {
10140                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10141                }
10142                let inner_offset;
10143                let mut inner_depth = depth.clone();
10144                if inlined {
10145                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10146                    inner_offset = next_offset;
10147                } else {
10148                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10149                    inner_depth.increment()?;
10150                }
10151                let val_ref =
10152                    self.ipv4_to_ipv6_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
10153                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10154                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10155                {
10156                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10157                }
10158                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10159                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10160                }
10161            }
10162
10163            next_offset += envelope_size;
10164            _next_ordinal_to_read += 1;
10165            if next_offset >= end_offset {
10166                return Ok(());
10167            }
10168
10169            // Decode unknown envelopes for gaps in ordinals.
10170            while _next_ordinal_to_read < 2 {
10171                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10172                _next_ordinal_to_read += 1;
10173                next_offset += envelope_size;
10174            }
10175
10176            let next_out_of_line = decoder.next_out_of_line();
10177            let handles_before = decoder.remaining_handles();
10178            if let Some((inlined, num_bytes, num_handles)) =
10179                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10180            {
10181                let member_inline_size =
10182                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10183                if inlined != (member_inline_size <= 4) {
10184                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10185                }
10186                let inner_offset;
10187                let mut inner_depth = depth.clone();
10188                if inlined {
10189                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10190                    inner_offset = next_offset;
10191                } else {
10192                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10193                    inner_depth.increment()?;
10194                }
10195                let val_ref =
10196                    self.ipv4_to_ipv6_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
10197                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10198                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10199                {
10200                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10201                }
10202                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10203                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10204                }
10205            }
10206
10207            next_offset += envelope_size;
10208            _next_ordinal_to_read += 1;
10209            if next_offset >= end_offset {
10210                return Ok(());
10211            }
10212
10213            // Decode unknown envelopes for gaps in ordinals.
10214            while _next_ordinal_to_read < 3 {
10215                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10216                _next_ordinal_to_read += 1;
10217                next_offset += envelope_size;
10218            }
10219
10220            let next_out_of_line = decoder.next_out_of_line();
10221            let handles_before = decoder.remaining_handles();
10222            if let Some((inlined, num_bytes, num_handles)) =
10223                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10224            {
10225                let member_inline_size =
10226                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10227                if inlined != (member_inline_size <= 4) {
10228                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10229                }
10230                let inner_offset;
10231                let mut inner_depth = depth.clone();
10232                if inlined {
10233                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10234                    inner_offset = next_offset;
10235                } else {
10236                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10237                    inner_depth.increment()?;
10238                }
10239                let val_ref =
10240                    self.ipv6_to_ipv4_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
10241                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10242                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10243                {
10244                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10245                }
10246                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10247                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10248                }
10249            }
10250
10251            next_offset += envelope_size;
10252            _next_ordinal_to_read += 1;
10253            if next_offset >= end_offset {
10254                return Ok(());
10255            }
10256
10257            // Decode unknown envelopes for gaps in ordinals.
10258            while _next_ordinal_to_read < 4 {
10259                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10260                _next_ordinal_to_read += 1;
10261                next_offset += envelope_size;
10262            }
10263
10264            let next_out_of_line = decoder.next_out_of_line();
10265            let handles_before = decoder.remaining_handles();
10266            if let Some((inlined, num_bytes, num_handles)) =
10267                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10268            {
10269                let member_inline_size =
10270                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10271                if inlined != (member_inline_size <= 4) {
10272                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10273                }
10274                let inner_offset;
10275                let mut inner_depth = depth.clone();
10276                if inlined {
10277                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10278                    inner_offset = next_offset;
10279                } else {
10280                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10281                    inner_depth.increment()?;
10282                }
10283                let val_ref =
10284                    self.ipv6_to_ipv4_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
10285                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10286                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10287                {
10288                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10289                }
10290                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10291                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10292                }
10293            }
10294
10295            next_offset += envelope_size;
10296
10297            // Decode the remaining unknown envelopes.
10298            while next_offset < end_offset {
10299                _next_ordinal_to_read += 1;
10300                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10301                next_offset += envelope_size;
10302            }
10303
10304            Ok(())
10305        }
10306    }
10307
10308    impl NetworkScanParameters {
10309        #[inline(always)]
10310        fn max_ordinal_present(&self) -> u64 {
10311            if let Some(_) = self.tx_power_dbm {
10312                return 2;
10313            }
10314            if let Some(_) = self.channels {
10315                return 1;
10316            }
10317            0
10318        }
10319    }
10320
10321    impl fidl::encoding::ValueTypeMarker for NetworkScanParameters {
10322        type Borrowed<'a> = &'a Self;
10323        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10324            value
10325        }
10326    }
10327
10328    unsafe impl fidl::encoding::TypeMarker for NetworkScanParameters {
10329        type Owned = Self;
10330
10331        #[inline(always)]
10332        fn inline_align(_context: fidl::encoding::Context) -> usize {
10333            8
10334        }
10335
10336        #[inline(always)]
10337        fn inline_size(_context: fidl::encoding::Context) -> usize {
10338            16
10339        }
10340    }
10341
10342    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NetworkScanParameters, D>
10343        for &NetworkScanParameters
10344    {
10345        unsafe fn encode(
10346            self,
10347            encoder: &mut fidl::encoding::Encoder<'_, D>,
10348            offset: usize,
10349            mut depth: fidl::encoding::Depth,
10350        ) -> fidl::Result<()> {
10351            encoder.debug_check_bounds::<NetworkScanParameters>(offset);
10352            // Vector header
10353            let max_ordinal: u64 = self.max_ordinal_present();
10354            encoder.write_num(max_ordinal, offset);
10355            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10356            // Calling encoder.out_of_line_offset(0) is not allowed.
10357            if max_ordinal == 0 {
10358                return Ok(());
10359            }
10360            depth.increment()?;
10361            let envelope_size = 8;
10362            let bytes_len = max_ordinal as usize * envelope_size;
10363            #[allow(unused_variables)]
10364            let offset = encoder.out_of_line_offset(bytes_len);
10365            let mut _prev_end_offset: usize = 0;
10366            if 1 > max_ordinal {
10367                return Ok(());
10368            }
10369
10370            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10371            // are envelope_size bytes.
10372            let cur_offset: usize = (1 - 1) * envelope_size;
10373
10374            // Zero reserved fields.
10375            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10376
10377            // Safety:
10378            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10379            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10380            //   envelope_size bytes, there is always sufficient room.
10381            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u16, 200>, D>(
10382                self.channels.as_ref().map(
10383                    <fidl::encoding::Vector<u16, 200> as fidl::encoding::ValueTypeMarker>::borrow,
10384                ),
10385                encoder,
10386                offset + cur_offset,
10387                depth,
10388            )?;
10389
10390            _prev_end_offset = cur_offset + envelope_size;
10391            if 2 > max_ordinal {
10392                return Ok(());
10393            }
10394
10395            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10396            // are envelope_size bytes.
10397            let cur_offset: usize = (2 - 1) * envelope_size;
10398
10399            // Zero reserved fields.
10400            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10401
10402            // Safety:
10403            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10404            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10405            //   envelope_size bytes, there is always sufficient room.
10406            fidl::encoding::encode_in_envelope_optional::<i8, D>(
10407                self.tx_power_dbm.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
10408                encoder,
10409                offset + cur_offset,
10410                depth,
10411            )?;
10412
10413            _prev_end_offset = cur_offset + envelope_size;
10414
10415            Ok(())
10416        }
10417    }
10418
10419    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NetworkScanParameters {
10420        #[inline(always)]
10421        fn new_empty() -> Self {
10422            Self::default()
10423        }
10424
10425        unsafe fn decode(
10426            &mut self,
10427            decoder: &mut fidl::encoding::Decoder<'_, D>,
10428            offset: usize,
10429            mut depth: fidl::encoding::Depth,
10430        ) -> fidl::Result<()> {
10431            decoder.debug_check_bounds::<Self>(offset);
10432            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10433                None => return Err(fidl::Error::NotNullable),
10434                Some(len) => len,
10435            };
10436            // Calling decoder.out_of_line_offset(0) is not allowed.
10437            if len == 0 {
10438                return Ok(());
10439            };
10440            depth.increment()?;
10441            let envelope_size = 8;
10442            let bytes_len = len * envelope_size;
10443            let offset = decoder.out_of_line_offset(bytes_len)?;
10444            // Decode the envelope for each type.
10445            let mut _next_ordinal_to_read = 0;
10446            let mut next_offset = offset;
10447            let end_offset = offset + bytes_len;
10448            _next_ordinal_to_read += 1;
10449            if next_offset >= end_offset {
10450                return Ok(());
10451            }
10452
10453            // Decode unknown envelopes for gaps in ordinals.
10454            while _next_ordinal_to_read < 1 {
10455                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10456                _next_ordinal_to_read += 1;
10457                next_offset += envelope_size;
10458            }
10459
10460            let next_out_of_line = decoder.next_out_of_line();
10461            let handles_before = decoder.remaining_handles();
10462            if let Some((inlined, num_bytes, num_handles)) =
10463                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10464            {
10465                let member_inline_size =
10466                    <fidl::encoding::Vector<u16, 200> as fidl::encoding::TypeMarker>::inline_size(
10467                        decoder.context,
10468                    );
10469                if inlined != (member_inline_size <= 4) {
10470                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10471                }
10472                let inner_offset;
10473                let mut inner_depth = depth.clone();
10474                if inlined {
10475                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10476                    inner_offset = next_offset;
10477                } else {
10478                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10479                    inner_depth.increment()?;
10480                }
10481                let val_ref = self
10482                    .channels
10483                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u16, 200>, D));
10484                fidl::decode!(fidl::encoding::Vector<u16, 200>, D, val_ref, decoder, inner_offset, inner_depth)?;
10485                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10486                {
10487                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10488                }
10489                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10490                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10491                }
10492            }
10493
10494            next_offset += envelope_size;
10495            _next_ordinal_to_read += 1;
10496            if next_offset >= end_offset {
10497                return Ok(());
10498            }
10499
10500            // Decode unknown envelopes for gaps in ordinals.
10501            while _next_ordinal_to_read < 2 {
10502                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10503                _next_ordinal_to_read += 1;
10504                next_offset += envelope_size;
10505            }
10506
10507            let next_out_of_line = decoder.next_out_of_line();
10508            let handles_before = decoder.remaining_handles();
10509            if let Some((inlined, num_bytes, num_handles)) =
10510                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10511            {
10512                let member_inline_size =
10513                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10514                if inlined != (member_inline_size <= 4) {
10515                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10516                }
10517                let inner_offset;
10518                let mut inner_depth = depth.clone();
10519                if inlined {
10520                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10521                    inner_offset = next_offset;
10522                } else {
10523                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10524                    inner_depth.increment()?;
10525                }
10526                let val_ref = self.tx_power_dbm.get_or_insert_with(|| fidl::new_empty!(i8, D));
10527                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
10528                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10529                {
10530                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10531                }
10532                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10533                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10534                }
10535            }
10536
10537            next_offset += envelope_size;
10538
10539            // Decode the remaining unknown envelopes.
10540            while next_offset < end_offset {
10541                _next_ordinal_to_read += 1;
10542                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10543                next_offset += envelope_size;
10544            }
10545
10546            Ok(())
10547        }
10548    }
10549
10550    impl OnMeshPrefix {
10551        #[inline(always)]
10552        fn max_ordinal_present(&self) -> u64 {
10553            if let Some(_) = self.slaac_valid {
10554                return 5;
10555            }
10556            if let Some(_) = self.slaac_preferred {
10557                return 4;
10558            }
10559            if let Some(_) = self.stable {
10560                return 3;
10561            }
10562            if let Some(_) = self.default_route_preference {
10563                return 2;
10564            }
10565            if let Some(_) = self.subnet {
10566                return 1;
10567            }
10568            0
10569        }
10570    }
10571
10572    impl fidl::encoding::ValueTypeMarker for OnMeshPrefix {
10573        type Borrowed<'a> = &'a Self;
10574        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10575            value
10576        }
10577    }
10578
10579    unsafe impl fidl::encoding::TypeMarker for OnMeshPrefix {
10580        type Owned = Self;
10581
10582        #[inline(always)]
10583        fn inline_align(_context: fidl::encoding::Context) -> usize {
10584            8
10585        }
10586
10587        #[inline(always)]
10588        fn inline_size(_context: fidl::encoding::Context) -> usize {
10589            16
10590        }
10591    }
10592
10593    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OnMeshPrefix, D>
10594        for &OnMeshPrefix
10595    {
10596        unsafe fn encode(
10597            self,
10598            encoder: &mut fidl::encoding::Encoder<'_, D>,
10599            offset: usize,
10600            mut depth: fidl::encoding::Depth,
10601        ) -> fidl::Result<()> {
10602            encoder.debug_check_bounds::<OnMeshPrefix>(offset);
10603            // Vector header
10604            let max_ordinal: u64 = self.max_ordinal_present();
10605            encoder.write_num(max_ordinal, offset);
10606            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10607            // Calling encoder.out_of_line_offset(0) is not allowed.
10608            if max_ordinal == 0 {
10609                return Ok(());
10610            }
10611            depth.increment()?;
10612            let envelope_size = 8;
10613            let bytes_len = max_ordinal as usize * envelope_size;
10614            #[allow(unused_variables)]
10615            let offset = encoder.out_of_line_offset(bytes_len);
10616            let mut _prev_end_offset: usize = 0;
10617            if 1 > max_ordinal {
10618                return Ok(());
10619            }
10620
10621            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10622            // are envelope_size bytes.
10623            let cur_offset: usize = (1 - 1) * envelope_size;
10624
10625            // Zero reserved fields.
10626            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10627
10628            // Safety:
10629            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10630            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10631            //   envelope_size bytes, there is always sufficient room.
10632            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>(
10633            self.subnet.as_ref().map(<fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow),
10634            encoder, offset + cur_offset, depth
10635        )?;
10636
10637            _prev_end_offset = cur_offset + envelope_size;
10638            if 2 > max_ordinal {
10639                return Ok(());
10640            }
10641
10642            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10643            // are envelope_size bytes.
10644            let cur_offset: usize = (2 - 1) * envelope_size;
10645
10646            // Zero reserved fields.
10647            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10648
10649            // Safety:
10650            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10651            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10652            //   envelope_size bytes, there is always sufficient room.
10653            fidl::encoding::encode_in_envelope_optional::<RoutePreference, D>(
10654                self.default_route_preference
10655                    .as_ref()
10656                    .map(<RoutePreference as fidl::encoding::ValueTypeMarker>::borrow),
10657                encoder,
10658                offset + cur_offset,
10659                depth,
10660            )?;
10661
10662            _prev_end_offset = cur_offset + envelope_size;
10663            if 3 > max_ordinal {
10664                return Ok(());
10665            }
10666
10667            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10668            // are envelope_size bytes.
10669            let cur_offset: usize = (3 - 1) * envelope_size;
10670
10671            // Zero reserved fields.
10672            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10673
10674            // Safety:
10675            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10676            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10677            //   envelope_size bytes, there is always sufficient room.
10678            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10679                self.stable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10680                encoder,
10681                offset + cur_offset,
10682                depth,
10683            )?;
10684
10685            _prev_end_offset = cur_offset + envelope_size;
10686            if 4 > max_ordinal {
10687                return Ok(());
10688            }
10689
10690            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10691            // are envelope_size bytes.
10692            let cur_offset: usize = (4 - 1) * envelope_size;
10693
10694            // Zero reserved fields.
10695            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10696
10697            // Safety:
10698            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10699            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10700            //   envelope_size bytes, there is always sufficient room.
10701            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10702                self.slaac_preferred
10703                    .as_ref()
10704                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10705                encoder,
10706                offset + cur_offset,
10707                depth,
10708            )?;
10709
10710            _prev_end_offset = cur_offset + envelope_size;
10711            if 5 > max_ordinal {
10712                return Ok(());
10713            }
10714
10715            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10716            // are envelope_size bytes.
10717            let cur_offset: usize = (5 - 1) * envelope_size;
10718
10719            // Zero reserved fields.
10720            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10721
10722            // Safety:
10723            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10724            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10725            //   envelope_size bytes, there is always sufficient room.
10726            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10727                self.slaac_valid.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10728                encoder,
10729                offset + cur_offset,
10730                depth,
10731            )?;
10732
10733            _prev_end_offset = cur_offset + envelope_size;
10734
10735            Ok(())
10736        }
10737    }
10738
10739    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OnMeshPrefix {
10740        #[inline(always)]
10741        fn new_empty() -> Self {
10742            Self::default()
10743        }
10744
10745        unsafe fn decode(
10746            &mut self,
10747            decoder: &mut fidl::encoding::Decoder<'_, D>,
10748            offset: usize,
10749            mut depth: fidl::encoding::Depth,
10750        ) -> fidl::Result<()> {
10751            decoder.debug_check_bounds::<Self>(offset);
10752            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10753                None => return Err(fidl::Error::NotNullable),
10754                Some(len) => len,
10755            };
10756            // Calling decoder.out_of_line_offset(0) is not allowed.
10757            if len == 0 {
10758                return Ok(());
10759            };
10760            depth.increment()?;
10761            let envelope_size = 8;
10762            let bytes_len = len * envelope_size;
10763            let offset = decoder.out_of_line_offset(bytes_len)?;
10764            // Decode the envelope for each type.
10765            let mut _next_ordinal_to_read = 0;
10766            let mut next_offset = offset;
10767            let end_offset = offset + bytes_len;
10768            _next_ordinal_to_read += 1;
10769            if next_offset >= end_offset {
10770                return Ok(());
10771            }
10772
10773            // Decode unknown envelopes for gaps in ordinals.
10774            while _next_ordinal_to_read < 1 {
10775                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10776                _next_ordinal_to_read += 1;
10777                next_offset += envelope_size;
10778            }
10779
10780            let next_out_of_line = decoder.next_out_of_line();
10781            let handles_before = decoder.remaining_handles();
10782            if let Some((inlined, num_bytes, num_handles)) =
10783                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10784            {
10785                let member_inline_size = <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10786                if inlined != (member_inline_size <= 4) {
10787                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10788                }
10789                let inner_offset;
10790                let mut inner_depth = depth.clone();
10791                if inlined {
10792                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10793                    inner_offset = next_offset;
10794                } else {
10795                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10796                    inner_depth.increment()?;
10797                }
10798                let val_ref = self.subnet.get_or_insert_with(|| {
10799                    fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D)
10800                });
10801                fidl::decode!(
10802                    fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
10803                    D,
10804                    val_ref,
10805                    decoder,
10806                    inner_offset,
10807                    inner_depth
10808                )?;
10809                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10810                {
10811                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10812                }
10813                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10814                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10815                }
10816            }
10817
10818            next_offset += envelope_size;
10819            _next_ordinal_to_read += 1;
10820            if next_offset >= end_offset {
10821                return Ok(());
10822            }
10823
10824            // Decode unknown envelopes for gaps in ordinals.
10825            while _next_ordinal_to_read < 2 {
10826                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10827                _next_ordinal_to_read += 1;
10828                next_offset += envelope_size;
10829            }
10830
10831            let next_out_of_line = decoder.next_out_of_line();
10832            let handles_before = decoder.remaining_handles();
10833            if let Some((inlined, num_bytes, num_handles)) =
10834                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10835            {
10836                let member_inline_size =
10837                    <RoutePreference as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10838                if inlined != (member_inline_size <= 4) {
10839                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10840                }
10841                let inner_offset;
10842                let mut inner_depth = depth.clone();
10843                if inlined {
10844                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10845                    inner_offset = next_offset;
10846                } else {
10847                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10848                    inner_depth.increment()?;
10849                }
10850                let val_ref = self
10851                    .default_route_preference
10852                    .get_or_insert_with(|| fidl::new_empty!(RoutePreference, D));
10853                fidl::decode!(RoutePreference, D, val_ref, decoder, inner_offset, inner_depth)?;
10854                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10855                {
10856                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10857                }
10858                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10859                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10860                }
10861            }
10862
10863            next_offset += envelope_size;
10864            _next_ordinal_to_read += 1;
10865            if next_offset >= end_offset {
10866                return Ok(());
10867            }
10868
10869            // Decode unknown envelopes for gaps in ordinals.
10870            while _next_ordinal_to_read < 3 {
10871                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10872                _next_ordinal_to_read += 1;
10873                next_offset += envelope_size;
10874            }
10875
10876            let next_out_of_line = decoder.next_out_of_line();
10877            let handles_before = decoder.remaining_handles();
10878            if let Some((inlined, num_bytes, num_handles)) =
10879                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10880            {
10881                let member_inline_size =
10882                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10883                if inlined != (member_inline_size <= 4) {
10884                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10885                }
10886                let inner_offset;
10887                let mut inner_depth = depth.clone();
10888                if inlined {
10889                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10890                    inner_offset = next_offset;
10891                } else {
10892                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10893                    inner_depth.increment()?;
10894                }
10895                let val_ref = self.stable.get_or_insert_with(|| fidl::new_empty!(bool, D));
10896                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10897                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10898                {
10899                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10900                }
10901                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10902                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10903                }
10904            }
10905
10906            next_offset += envelope_size;
10907            _next_ordinal_to_read += 1;
10908            if next_offset >= end_offset {
10909                return Ok(());
10910            }
10911
10912            // Decode unknown envelopes for gaps in ordinals.
10913            while _next_ordinal_to_read < 4 {
10914                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10915                _next_ordinal_to_read += 1;
10916                next_offset += envelope_size;
10917            }
10918
10919            let next_out_of_line = decoder.next_out_of_line();
10920            let handles_before = decoder.remaining_handles();
10921            if let Some((inlined, num_bytes, num_handles)) =
10922                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10923            {
10924                let member_inline_size =
10925                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10926                if inlined != (member_inline_size <= 4) {
10927                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10928                }
10929                let inner_offset;
10930                let mut inner_depth = depth.clone();
10931                if inlined {
10932                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10933                    inner_offset = next_offset;
10934                } else {
10935                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10936                    inner_depth.increment()?;
10937                }
10938                let val_ref = self.slaac_preferred.get_or_insert_with(|| fidl::new_empty!(bool, D));
10939                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10940                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10941                {
10942                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10943                }
10944                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10945                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10946                }
10947            }
10948
10949            next_offset += envelope_size;
10950            _next_ordinal_to_read += 1;
10951            if next_offset >= end_offset {
10952                return Ok(());
10953            }
10954
10955            // Decode unknown envelopes for gaps in ordinals.
10956            while _next_ordinal_to_read < 5 {
10957                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10958                _next_ordinal_to_read += 1;
10959                next_offset += envelope_size;
10960            }
10961
10962            let next_out_of_line = decoder.next_out_of_line();
10963            let handles_before = decoder.remaining_handles();
10964            if let Some((inlined, num_bytes, num_handles)) =
10965                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10966            {
10967                let member_inline_size =
10968                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10969                if inlined != (member_inline_size <= 4) {
10970                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10971                }
10972                let inner_offset;
10973                let mut inner_depth = depth.clone();
10974                if inlined {
10975                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10976                    inner_offset = next_offset;
10977                } else {
10978                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10979                    inner_depth.increment()?;
10980                }
10981                let val_ref = self.slaac_valid.get_or_insert_with(|| fidl::new_empty!(bool, D));
10982                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10983                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10984                {
10985                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10986                }
10987                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10988                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10989                }
10990            }
10991
10992            next_offset += envelope_size;
10993
10994            // Decode the remaining unknown envelopes.
10995            while next_offset < end_offset {
10996                _next_ordinal_to_read += 1;
10997                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10998                next_offset += envelope_size;
10999            }
11000
11001            Ok(())
11002        }
11003    }
11004
11005    impl PdProcessedRaInfo {
11006        #[inline(always)]
11007        fn max_ordinal_present(&self) -> u64 {
11008            if let Some(_) = self.last_platform_ra_msec {
11009                return 3;
11010            }
11011            if let Some(_) = self.num_platform_pio_processed {
11012                return 2;
11013            }
11014            if let Some(_) = self.num_platform_ra_received {
11015                return 1;
11016            }
11017            0
11018        }
11019    }
11020
11021    impl fidl::encoding::ValueTypeMarker for PdProcessedRaInfo {
11022        type Borrowed<'a> = &'a Self;
11023        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11024            value
11025        }
11026    }
11027
11028    unsafe impl fidl::encoding::TypeMarker for PdProcessedRaInfo {
11029        type Owned = Self;
11030
11031        #[inline(always)]
11032        fn inline_align(_context: fidl::encoding::Context) -> usize {
11033            8
11034        }
11035
11036        #[inline(always)]
11037        fn inline_size(_context: fidl::encoding::Context) -> usize {
11038            16
11039        }
11040    }
11041
11042    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PdProcessedRaInfo, D>
11043        for &PdProcessedRaInfo
11044    {
11045        unsafe fn encode(
11046            self,
11047            encoder: &mut fidl::encoding::Encoder<'_, D>,
11048            offset: usize,
11049            mut depth: fidl::encoding::Depth,
11050        ) -> fidl::Result<()> {
11051            encoder.debug_check_bounds::<PdProcessedRaInfo>(offset);
11052            // Vector header
11053            let max_ordinal: u64 = self.max_ordinal_present();
11054            encoder.write_num(max_ordinal, offset);
11055            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11056            // Calling encoder.out_of_line_offset(0) is not allowed.
11057            if max_ordinal == 0 {
11058                return Ok(());
11059            }
11060            depth.increment()?;
11061            let envelope_size = 8;
11062            let bytes_len = max_ordinal as usize * envelope_size;
11063            #[allow(unused_variables)]
11064            let offset = encoder.out_of_line_offset(bytes_len);
11065            let mut _prev_end_offset: usize = 0;
11066            if 1 > max_ordinal {
11067                return Ok(());
11068            }
11069
11070            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11071            // are envelope_size bytes.
11072            let cur_offset: usize = (1 - 1) * envelope_size;
11073
11074            // Zero reserved fields.
11075            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11076
11077            // Safety:
11078            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11079            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11080            //   envelope_size bytes, there is always sufficient room.
11081            fidl::encoding::encode_in_envelope_optional::<u32, D>(
11082                self.num_platform_ra_received
11083                    .as_ref()
11084                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
11085                encoder,
11086                offset + cur_offset,
11087                depth,
11088            )?;
11089
11090            _prev_end_offset = cur_offset + envelope_size;
11091            if 2 > max_ordinal {
11092                return Ok(());
11093            }
11094
11095            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11096            // are envelope_size bytes.
11097            let cur_offset: usize = (2 - 1) * envelope_size;
11098
11099            // Zero reserved fields.
11100            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11101
11102            // Safety:
11103            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11104            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11105            //   envelope_size bytes, there is always sufficient room.
11106            fidl::encoding::encode_in_envelope_optional::<u32, D>(
11107                self.num_platform_pio_processed
11108                    .as_ref()
11109                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
11110                encoder,
11111                offset + cur_offset,
11112                depth,
11113            )?;
11114
11115            _prev_end_offset = cur_offset + envelope_size;
11116            if 3 > max_ordinal {
11117                return Ok(());
11118            }
11119
11120            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11121            // are envelope_size bytes.
11122            let cur_offset: usize = (3 - 1) * envelope_size;
11123
11124            // Zero reserved fields.
11125            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11126
11127            // Safety:
11128            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11129            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11130            //   envelope_size bytes, there is always sufficient room.
11131            fidl::encoding::encode_in_envelope_optional::<u32, D>(
11132                self.last_platform_ra_msec
11133                    .as_ref()
11134                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
11135                encoder,
11136                offset + cur_offset,
11137                depth,
11138            )?;
11139
11140            _prev_end_offset = cur_offset + envelope_size;
11141
11142            Ok(())
11143        }
11144    }
11145
11146    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PdProcessedRaInfo {
11147        #[inline(always)]
11148        fn new_empty() -> Self {
11149            Self::default()
11150        }
11151
11152        unsafe fn decode(
11153            &mut self,
11154            decoder: &mut fidl::encoding::Decoder<'_, D>,
11155            offset: usize,
11156            mut depth: fidl::encoding::Depth,
11157        ) -> fidl::Result<()> {
11158            decoder.debug_check_bounds::<Self>(offset);
11159            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11160                None => return Err(fidl::Error::NotNullable),
11161                Some(len) => len,
11162            };
11163            // Calling decoder.out_of_line_offset(0) is not allowed.
11164            if len == 0 {
11165                return Ok(());
11166            };
11167            depth.increment()?;
11168            let envelope_size = 8;
11169            let bytes_len = len * envelope_size;
11170            let offset = decoder.out_of_line_offset(bytes_len)?;
11171            // Decode the envelope for each type.
11172            let mut _next_ordinal_to_read = 0;
11173            let mut next_offset = offset;
11174            let end_offset = offset + bytes_len;
11175            _next_ordinal_to_read += 1;
11176            if next_offset >= end_offset {
11177                return Ok(());
11178            }
11179
11180            // Decode unknown envelopes for gaps in ordinals.
11181            while _next_ordinal_to_read < 1 {
11182                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11183                _next_ordinal_to_read += 1;
11184                next_offset += envelope_size;
11185            }
11186
11187            let next_out_of_line = decoder.next_out_of_line();
11188            let handles_before = decoder.remaining_handles();
11189            if let Some((inlined, num_bytes, num_handles)) =
11190                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11191            {
11192                let member_inline_size =
11193                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11194                if inlined != (member_inline_size <= 4) {
11195                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11196                }
11197                let inner_offset;
11198                let mut inner_depth = depth.clone();
11199                if inlined {
11200                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11201                    inner_offset = next_offset;
11202                } else {
11203                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11204                    inner_depth.increment()?;
11205                }
11206                let val_ref =
11207                    self.num_platform_ra_received.get_or_insert_with(|| fidl::new_empty!(u32, D));
11208                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
11209                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11210                {
11211                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11212                }
11213                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11214                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11215                }
11216            }
11217
11218            next_offset += envelope_size;
11219            _next_ordinal_to_read += 1;
11220            if next_offset >= end_offset {
11221                return Ok(());
11222            }
11223
11224            // Decode unknown envelopes for gaps in ordinals.
11225            while _next_ordinal_to_read < 2 {
11226                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11227                _next_ordinal_to_read += 1;
11228                next_offset += envelope_size;
11229            }
11230
11231            let next_out_of_line = decoder.next_out_of_line();
11232            let handles_before = decoder.remaining_handles();
11233            if let Some((inlined, num_bytes, num_handles)) =
11234                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11235            {
11236                let member_inline_size =
11237                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11238                if inlined != (member_inline_size <= 4) {
11239                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11240                }
11241                let inner_offset;
11242                let mut inner_depth = depth.clone();
11243                if inlined {
11244                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11245                    inner_offset = next_offset;
11246                } else {
11247                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11248                    inner_depth.increment()?;
11249                }
11250                let val_ref =
11251                    self.num_platform_pio_processed.get_or_insert_with(|| fidl::new_empty!(u32, D));
11252                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
11253                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11254                {
11255                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11256                }
11257                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11258                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11259                }
11260            }
11261
11262            next_offset += envelope_size;
11263            _next_ordinal_to_read += 1;
11264            if next_offset >= end_offset {
11265                return Ok(());
11266            }
11267
11268            // Decode unknown envelopes for gaps in ordinals.
11269            while _next_ordinal_to_read < 3 {
11270                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11271                _next_ordinal_to_read += 1;
11272                next_offset += envelope_size;
11273            }
11274
11275            let next_out_of_line = decoder.next_out_of_line();
11276            let handles_before = decoder.remaining_handles();
11277            if let Some((inlined, num_bytes, num_handles)) =
11278                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11279            {
11280                let member_inline_size =
11281                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11282                if inlined != (member_inline_size <= 4) {
11283                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11284                }
11285                let inner_offset;
11286                let mut inner_depth = depth.clone();
11287                if inlined {
11288                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11289                    inner_offset = next_offset;
11290                } else {
11291                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11292                    inner_depth.increment()?;
11293                }
11294                let val_ref =
11295                    self.last_platform_ra_msec.get_or_insert_with(|| fidl::new_empty!(u32, D));
11296                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
11297                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11298                {
11299                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11300                }
11301                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11302                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11303                }
11304            }
11305
11306            next_offset += envelope_size;
11307
11308            // Decode the remaining unknown envelopes.
11309            while next_offset < end_offset {
11310                _next_ordinal_to_read += 1;
11311                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11312                next_offset += envelope_size;
11313            }
11314
11315            Ok(())
11316        }
11317    }
11318
11319    impl SrpServerInfo {
11320        #[inline(always)]
11321        fn max_ordinal_present(&self) -> u64 {
11322            if let Some(_) = self.services_registration {
11323                return 6;
11324            }
11325            if let Some(_) = self.hosts_registration {
11326                return 5;
11327            }
11328            if let Some(_) = self.response_counters {
11329                return 4;
11330            }
11331            if let Some(_) = self.address_mode {
11332                return 3;
11333            }
11334            if let Some(_) = self.port {
11335                return 2;
11336            }
11337            if let Some(_) = self.state {
11338                return 1;
11339            }
11340            0
11341        }
11342    }
11343
11344    impl fidl::encoding::ValueTypeMarker for SrpServerInfo {
11345        type Borrowed<'a> = &'a Self;
11346        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11347            value
11348        }
11349    }
11350
11351    unsafe impl fidl::encoding::TypeMarker for SrpServerInfo {
11352        type Owned = Self;
11353
11354        #[inline(always)]
11355        fn inline_align(_context: fidl::encoding::Context) -> usize {
11356            8
11357        }
11358
11359        #[inline(always)]
11360        fn inline_size(_context: fidl::encoding::Context) -> usize {
11361            16
11362        }
11363    }
11364
11365    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SrpServerInfo, D>
11366        for &SrpServerInfo
11367    {
11368        unsafe fn encode(
11369            self,
11370            encoder: &mut fidl::encoding::Encoder<'_, D>,
11371            offset: usize,
11372            mut depth: fidl::encoding::Depth,
11373        ) -> fidl::Result<()> {
11374            encoder.debug_check_bounds::<SrpServerInfo>(offset);
11375            // Vector header
11376            let max_ordinal: u64 = self.max_ordinal_present();
11377            encoder.write_num(max_ordinal, offset);
11378            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11379            // Calling encoder.out_of_line_offset(0) is not allowed.
11380            if max_ordinal == 0 {
11381                return Ok(());
11382            }
11383            depth.increment()?;
11384            let envelope_size = 8;
11385            let bytes_len = max_ordinal as usize * envelope_size;
11386            #[allow(unused_variables)]
11387            let offset = encoder.out_of_line_offset(bytes_len);
11388            let mut _prev_end_offset: usize = 0;
11389            if 1 > max_ordinal {
11390                return Ok(());
11391            }
11392
11393            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11394            // are envelope_size bytes.
11395            let cur_offset: usize = (1 - 1) * envelope_size;
11396
11397            // Zero reserved fields.
11398            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11399
11400            // Safety:
11401            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11402            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11403            //   envelope_size bytes, there is always sufficient room.
11404            fidl::encoding::encode_in_envelope_optional::<SrpServerState, D>(
11405                self.state
11406                    .as_ref()
11407                    .map(<SrpServerState as fidl::encoding::ValueTypeMarker>::borrow),
11408                encoder,
11409                offset + cur_offset,
11410                depth,
11411            )?;
11412
11413            _prev_end_offset = cur_offset + envelope_size;
11414            if 2 > max_ordinal {
11415                return Ok(());
11416            }
11417
11418            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11419            // are envelope_size bytes.
11420            let cur_offset: usize = (2 - 1) * envelope_size;
11421
11422            // Zero reserved fields.
11423            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11424
11425            // Safety:
11426            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11427            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11428            //   envelope_size bytes, there is always sufficient room.
11429            fidl::encoding::encode_in_envelope_optional::<u16, D>(
11430                self.port.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
11431                encoder,
11432                offset + cur_offset,
11433                depth,
11434            )?;
11435
11436            _prev_end_offset = cur_offset + envelope_size;
11437            if 3 > max_ordinal {
11438                return Ok(());
11439            }
11440
11441            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11442            // are envelope_size bytes.
11443            let cur_offset: usize = (3 - 1) * envelope_size;
11444
11445            // Zero reserved fields.
11446            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11447
11448            // Safety:
11449            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11450            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11451            //   envelope_size bytes, there is always sufficient room.
11452            fidl::encoding::encode_in_envelope_optional::<SrpServerAddressMode, D>(
11453                self.address_mode
11454                    .as_ref()
11455                    .map(<SrpServerAddressMode as fidl::encoding::ValueTypeMarker>::borrow),
11456                encoder,
11457                offset + cur_offset,
11458                depth,
11459            )?;
11460
11461            _prev_end_offset = cur_offset + envelope_size;
11462            if 4 > max_ordinal {
11463                return Ok(());
11464            }
11465
11466            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11467            // are envelope_size bytes.
11468            let cur_offset: usize = (4 - 1) * envelope_size;
11469
11470            // Zero reserved fields.
11471            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11472
11473            // Safety:
11474            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11475            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11476            //   envelope_size bytes, there is always sufficient room.
11477            fidl::encoding::encode_in_envelope_optional::<SrpServerResponseCounters, D>(
11478                self.response_counters
11479                    .as_ref()
11480                    .map(<SrpServerResponseCounters as fidl::encoding::ValueTypeMarker>::borrow),
11481                encoder,
11482                offset + cur_offset,
11483                depth,
11484            )?;
11485
11486            _prev_end_offset = cur_offset + envelope_size;
11487            if 5 > max_ordinal {
11488                return Ok(());
11489            }
11490
11491            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11492            // are envelope_size bytes.
11493            let cur_offset: usize = (5 - 1) * envelope_size;
11494
11495            // Zero reserved fields.
11496            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11497
11498            // Safety:
11499            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11500            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11501            //   envelope_size bytes, there is always sufficient room.
11502            fidl::encoding::encode_in_envelope_optional::<SrpServerRegistration, D>(
11503                self.hosts_registration
11504                    .as_ref()
11505                    .map(<SrpServerRegistration as fidl::encoding::ValueTypeMarker>::borrow),
11506                encoder,
11507                offset + cur_offset,
11508                depth,
11509            )?;
11510
11511            _prev_end_offset = cur_offset + envelope_size;
11512            if 6 > max_ordinal {
11513                return Ok(());
11514            }
11515
11516            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11517            // are envelope_size bytes.
11518            let cur_offset: usize = (6 - 1) * envelope_size;
11519
11520            // Zero reserved fields.
11521            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11522
11523            // Safety:
11524            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11525            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11526            //   envelope_size bytes, there is always sufficient room.
11527            fidl::encoding::encode_in_envelope_optional::<SrpServerRegistration, D>(
11528                self.services_registration
11529                    .as_ref()
11530                    .map(<SrpServerRegistration as fidl::encoding::ValueTypeMarker>::borrow),
11531                encoder,
11532                offset + cur_offset,
11533                depth,
11534            )?;
11535
11536            _prev_end_offset = cur_offset + envelope_size;
11537
11538            Ok(())
11539        }
11540    }
11541
11542    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SrpServerInfo {
11543        #[inline(always)]
11544        fn new_empty() -> Self {
11545            Self::default()
11546        }
11547
11548        unsafe fn decode(
11549            &mut self,
11550            decoder: &mut fidl::encoding::Decoder<'_, D>,
11551            offset: usize,
11552            mut depth: fidl::encoding::Depth,
11553        ) -> fidl::Result<()> {
11554            decoder.debug_check_bounds::<Self>(offset);
11555            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11556                None => return Err(fidl::Error::NotNullable),
11557                Some(len) => len,
11558            };
11559            // Calling decoder.out_of_line_offset(0) is not allowed.
11560            if len == 0 {
11561                return Ok(());
11562            };
11563            depth.increment()?;
11564            let envelope_size = 8;
11565            let bytes_len = len * envelope_size;
11566            let offset = decoder.out_of_line_offset(bytes_len)?;
11567            // Decode the envelope for each type.
11568            let mut _next_ordinal_to_read = 0;
11569            let mut next_offset = offset;
11570            let end_offset = offset + bytes_len;
11571            _next_ordinal_to_read += 1;
11572            if next_offset >= end_offset {
11573                return Ok(());
11574            }
11575
11576            // Decode unknown envelopes for gaps in ordinals.
11577            while _next_ordinal_to_read < 1 {
11578                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11579                _next_ordinal_to_read += 1;
11580                next_offset += envelope_size;
11581            }
11582
11583            let next_out_of_line = decoder.next_out_of_line();
11584            let handles_before = decoder.remaining_handles();
11585            if let Some((inlined, num_bytes, num_handles)) =
11586                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11587            {
11588                let member_inline_size =
11589                    <SrpServerState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11590                if inlined != (member_inline_size <= 4) {
11591                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11592                }
11593                let inner_offset;
11594                let mut inner_depth = depth.clone();
11595                if inlined {
11596                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11597                    inner_offset = next_offset;
11598                } else {
11599                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11600                    inner_depth.increment()?;
11601                }
11602                let val_ref = self.state.get_or_insert_with(|| fidl::new_empty!(SrpServerState, D));
11603                fidl::decode!(SrpServerState, D, val_ref, decoder, inner_offset, inner_depth)?;
11604                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11605                {
11606                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11607                }
11608                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11609                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11610                }
11611            }
11612
11613            next_offset += envelope_size;
11614            _next_ordinal_to_read += 1;
11615            if next_offset >= end_offset {
11616                return Ok(());
11617            }
11618
11619            // Decode unknown envelopes for gaps in ordinals.
11620            while _next_ordinal_to_read < 2 {
11621                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11622                _next_ordinal_to_read += 1;
11623                next_offset += envelope_size;
11624            }
11625
11626            let next_out_of_line = decoder.next_out_of_line();
11627            let handles_before = decoder.remaining_handles();
11628            if let Some((inlined, num_bytes, num_handles)) =
11629                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11630            {
11631                let member_inline_size =
11632                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11633                if inlined != (member_inline_size <= 4) {
11634                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11635                }
11636                let inner_offset;
11637                let mut inner_depth = depth.clone();
11638                if inlined {
11639                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11640                    inner_offset = next_offset;
11641                } else {
11642                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11643                    inner_depth.increment()?;
11644                }
11645                let val_ref = self.port.get_or_insert_with(|| fidl::new_empty!(u16, D));
11646                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
11647                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11648                {
11649                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11650                }
11651                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11652                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11653                }
11654            }
11655
11656            next_offset += envelope_size;
11657            _next_ordinal_to_read += 1;
11658            if next_offset >= end_offset {
11659                return Ok(());
11660            }
11661
11662            // Decode unknown envelopes for gaps in ordinals.
11663            while _next_ordinal_to_read < 3 {
11664                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11665                _next_ordinal_to_read += 1;
11666                next_offset += envelope_size;
11667            }
11668
11669            let next_out_of_line = decoder.next_out_of_line();
11670            let handles_before = decoder.remaining_handles();
11671            if let Some((inlined, num_bytes, num_handles)) =
11672                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11673            {
11674                let member_inline_size =
11675                    <SrpServerAddressMode as fidl::encoding::TypeMarker>::inline_size(
11676                        decoder.context,
11677                    );
11678                if inlined != (member_inline_size <= 4) {
11679                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11680                }
11681                let inner_offset;
11682                let mut inner_depth = depth.clone();
11683                if inlined {
11684                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11685                    inner_offset = next_offset;
11686                } else {
11687                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11688                    inner_depth.increment()?;
11689                }
11690                let val_ref = self
11691                    .address_mode
11692                    .get_or_insert_with(|| fidl::new_empty!(SrpServerAddressMode, D));
11693                fidl::decode!(
11694                    SrpServerAddressMode,
11695                    D,
11696                    val_ref,
11697                    decoder,
11698                    inner_offset,
11699                    inner_depth
11700                )?;
11701                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11702                {
11703                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11704                }
11705                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11706                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11707                }
11708            }
11709
11710            next_offset += envelope_size;
11711            _next_ordinal_to_read += 1;
11712            if next_offset >= end_offset {
11713                return Ok(());
11714            }
11715
11716            // Decode unknown envelopes for gaps in ordinals.
11717            while _next_ordinal_to_read < 4 {
11718                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11719                _next_ordinal_to_read += 1;
11720                next_offset += envelope_size;
11721            }
11722
11723            let next_out_of_line = decoder.next_out_of_line();
11724            let handles_before = decoder.remaining_handles();
11725            if let Some((inlined, num_bytes, num_handles)) =
11726                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11727            {
11728                let member_inline_size =
11729                    <SrpServerResponseCounters as fidl::encoding::TypeMarker>::inline_size(
11730                        decoder.context,
11731                    );
11732                if inlined != (member_inline_size <= 4) {
11733                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11734                }
11735                let inner_offset;
11736                let mut inner_depth = depth.clone();
11737                if inlined {
11738                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11739                    inner_offset = next_offset;
11740                } else {
11741                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11742                    inner_depth.increment()?;
11743                }
11744                let val_ref = self
11745                    .response_counters
11746                    .get_or_insert_with(|| fidl::new_empty!(SrpServerResponseCounters, D));
11747                fidl::decode!(
11748                    SrpServerResponseCounters,
11749                    D,
11750                    val_ref,
11751                    decoder,
11752                    inner_offset,
11753                    inner_depth
11754                )?;
11755                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11756                {
11757                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11758                }
11759                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11760                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11761                }
11762            }
11763
11764            next_offset += envelope_size;
11765            _next_ordinal_to_read += 1;
11766            if next_offset >= end_offset {
11767                return Ok(());
11768            }
11769
11770            // Decode unknown envelopes for gaps in ordinals.
11771            while _next_ordinal_to_read < 5 {
11772                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11773                _next_ordinal_to_read += 1;
11774                next_offset += envelope_size;
11775            }
11776
11777            let next_out_of_line = decoder.next_out_of_line();
11778            let handles_before = decoder.remaining_handles();
11779            if let Some((inlined, num_bytes, num_handles)) =
11780                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11781            {
11782                let member_inline_size =
11783                    <SrpServerRegistration as fidl::encoding::TypeMarker>::inline_size(
11784                        decoder.context,
11785                    );
11786                if inlined != (member_inline_size <= 4) {
11787                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11788                }
11789                let inner_offset;
11790                let mut inner_depth = depth.clone();
11791                if inlined {
11792                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11793                    inner_offset = next_offset;
11794                } else {
11795                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11796                    inner_depth.increment()?;
11797                }
11798                let val_ref = self
11799                    .hosts_registration
11800                    .get_or_insert_with(|| fidl::new_empty!(SrpServerRegistration, D));
11801                fidl::decode!(
11802                    SrpServerRegistration,
11803                    D,
11804                    val_ref,
11805                    decoder,
11806                    inner_offset,
11807                    inner_depth
11808                )?;
11809                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11810                {
11811                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11812                }
11813                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11814                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11815                }
11816            }
11817
11818            next_offset += envelope_size;
11819            _next_ordinal_to_read += 1;
11820            if next_offset >= end_offset {
11821                return Ok(());
11822            }
11823
11824            // Decode unknown envelopes for gaps in ordinals.
11825            while _next_ordinal_to_read < 6 {
11826                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11827                _next_ordinal_to_read += 1;
11828                next_offset += envelope_size;
11829            }
11830
11831            let next_out_of_line = decoder.next_out_of_line();
11832            let handles_before = decoder.remaining_handles();
11833            if let Some((inlined, num_bytes, num_handles)) =
11834                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11835            {
11836                let member_inline_size =
11837                    <SrpServerRegistration as fidl::encoding::TypeMarker>::inline_size(
11838                        decoder.context,
11839                    );
11840                if inlined != (member_inline_size <= 4) {
11841                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11842                }
11843                let inner_offset;
11844                let mut inner_depth = depth.clone();
11845                if inlined {
11846                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11847                    inner_offset = next_offset;
11848                } else {
11849                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11850                    inner_depth.increment()?;
11851                }
11852                let val_ref = self
11853                    .services_registration
11854                    .get_or_insert_with(|| fidl::new_empty!(SrpServerRegistration, D));
11855                fidl::decode!(
11856                    SrpServerRegistration,
11857                    D,
11858                    val_ref,
11859                    decoder,
11860                    inner_offset,
11861                    inner_depth
11862                )?;
11863                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11864                {
11865                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11866                }
11867                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11868                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11869                }
11870            }
11871
11872            next_offset += envelope_size;
11873
11874            // Decode the remaining unknown envelopes.
11875            while next_offset < end_offset {
11876                _next_ordinal_to_read += 1;
11877                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11878                next_offset += envelope_size;
11879            }
11880
11881            Ok(())
11882        }
11883    }
11884
11885    impl SrpServerRegistration {
11886        #[inline(always)]
11887        fn max_ordinal_present(&self) -> u64 {
11888            if let Some(_) = self.remaining_key_lease_time_total {
11889                return 6;
11890            }
11891            if let Some(_) = self.remaining_lease_time_total {
11892                return 5;
11893            }
11894            if let Some(_) = self.key_lease_time_total {
11895                return 4;
11896            }
11897            if let Some(_) = self.lease_time_total {
11898                return 3;
11899            }
11900            if let Some(_) = self.deleted_count {
11901                return 2;
11902            }
11903            if let Some(_) = self.fresh_count {
11904                return 1;
11905            }
11906            0
11907        }
11908    }
11909
11910    impl fidl::encoding::ValueTypeMarker for SrpServerRegistration {
11911        type Borrowed<'a> = &'a Self;
11912        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11913            value
11914        }
11915    }
11916
11917    unsafe impl fidl::encoding::TypeMarker for SrpServerRegistration {
11918        type Owned = Self;
11919
11920        #[inline(always)]
11921        fn inline_align(_context: fidl::encoding::Context) -> usize {
11922            8
11923        }
11924
11925        #[inline(always)]
11926        fn inline_size(_context: fidl::encoding::Context) -> usize {
11927            16
11928        }
11929    }
11930
11931    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SrpServerRegistration, D>
11932        for &SrpServerRegistration
11933    {
11934        unsafe fn encode(
11935            self,
11936            encoder: &mut fidl::encoding::Encoder<'_, D>,
11937            offset: usize,
11938            mut depth: fidl::encoding::Depth,
11939        ) -> fidl::Result<()> {
11940            encoder.debug_check_bounds::<SrpServerRegistration>(offset);
11941            // Vector header
11942            let max_ordinal: u64 = self.max_ordinal_present();
11943            encoder.write_num(max_ordinal, offset);
11944            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11945            // Calling encoder.out_of_line_offset(0) is not allowed.
11946            if max_ordinal == 0 {
11947                return Ok(());
11948            }
11949            depth.increment()?;
11950            let envelope_size = 8;
11951            let bytes_len = max_ordinal as usize * envelope_size;
11952            #[allow(unused_variables)]
11953            let offset = encoder.out_of_line_offset(bytes_len);
11954            let mut _prev_end_offset: usize = 0;
11955            if 1 > max_ordinal {
11956                return Ok(());
11957            }
11958
11959            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11960            // are envelope_size bytes.
11961            let cur_offset: usize = (1 - 1) * envelope_size;
11962
11963            // Zero reserved fields.
11964            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11965
11966            // Safety:
11967            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11968            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11969            //   envelope_size bytes, there is always sufficient room.
11970            fidl::encoding::encode_in_envelope_optional::<u32, D>(
11971                self.fresh_count.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
11972                encoder,
11973                offset + cur_offset,
11974                depth,
11975            )?;
11976
11977            _prev_end_offset = cur_offset + envelope_size;
11978            if 2 > max_ordinal {
11979                return Ok(());
11980            }
11981
11982            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11983            // are envelope_size bytes.
11984            let cur_offset: usize = (2 - 1) * envelope_size;
11985
11986            // Zero reserved fields.
11987            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11988
11989            // Safety:
11990            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11991            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11992            //   envelope_size bytes, there is always sufficient room.
11993            fidl::encoding::encode_in_envelope_optional::<u32, D>(
11994                self.deleted_count.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
11995                encoder,
11996                offset + cur_offset,
11997                depth,
11998            )?;
11999
12000            _prev_end_offset = cur_offset + envelope_size;
12001            if 3 > max_ordinal {
12002                return Ok(());
12003            }
12004
12005            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12006            // are envelope_size bytes.
12007            let cur_offset: usize = (3 - 1) * envelope_size;
12008
12009            // Zero reserved fields.
12010            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12011
12012            // Safety:
12013            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12014            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12015            //   envelope_size bytes, there is always sufficient room.
12016            fidl::encoding::encode_in_envelope_optional::<i64, D>(
12017                self.lease_time_total
12018                    .as_ref()
12019                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
12020                encoder,
12021                offset + cur_offset,
12022                depth,
12023            )?;
12024
12025            _prev_end_offset = cur_offset + envelope_size;
12026            if 4 > max_ordinal {
12027                return Ok(());
12028            }
12029
12030            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12031            // are envelope_size bytes.
12032            let cur_offset: usize = (4 - 1) * envelope_size;
12033
12034            // Zero reserved fields.
12035            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12036
12037            // Safety:
12038            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12039            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12040            //   envelope_size bytes, there is always sufficient room.
12041            fidl::encoding::encode_in_envelope_optional::<i64, D>(
12042                self.key_lease_time_total
12043                    .as_ref()
12044                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
12045                encoder,
12046                offset + cur_offset,
12047                depth,
12048            )?;
12049
12050            _prev_end_offset = cur_offset + envelope_size;
12051            if 5 > max_ordinal {
12052                return Ok(());
12053            }
12054
12055            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12056            // are envelope_size bytes.
12057            let cur_offset: usize = (5 - 1) * envelope_size;
12058
12059            // Zero reserved fields.
12060            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12061
12062            // Safety:
12063            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12064            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12065            //   envelope_size bytes, there is always sufficient room.
12066            fidl::encoding::encode_in_envelope_optional::<i64, D>(
12067                self.remaining_lease_time_total
12068                    .as_ref()
12069                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
12070                encoder,
12071                offset + cur_offset,
12072                depth,
12073            )?;
12074
12075            _prev_end_offset = cur_offset + envelope_size;
12076            if 6 > max_ordinal {
12077                return Ok(());
12078            }
12079
12080            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12081            // are envelope_size bytes.
12082            let cur_offset: usize = (6 - 1) * envelope_size;
12083
12084            // Zero reserved fields.
12085            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12086
12087            // Safety:
12088            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12089            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12090            //   envelope_size bytes, there is always sufficient room.
12091            fidl::encoding::encode_in_envelope_optional::<i64, D>(
12092                self.remaining_key_lease_time_total
12093                    .as_ref()
12094                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
12095                encoder,
12096                offset + cur_offset,
12097                depth,
12098            )?;
12099
12100            _prev_end_offset = cur_offset + envelope_size;
12101
12102            Ok(())
12103        }
12104    }
12105
12106    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SrpServerRegistration {
12107        #[inline(always)]
12108        fn new_empty() -> Self {
12109            Self::default()
12110        }
12111
12112        unsafe fn decode(
12113            &mut self,
12114            decoder: &mut fidl::encoding::Decoder<'_, D>,
12115            offset: usize,
12116            mut depth: fidl::encoding::Depth,
12117        ) -> fidl::Result<()> {
12118            decoder.debug_check_bounds::<Self>(offset);
12119            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12120                None => return Err(fidl::Error::NotNullable),
12121                Some(len) => len,
12122            };
12123            // Calling decoder.out_of_line_offset(0) is not allowed.
12124            if len == 0 {
12125                return Ok(());
12126            };
12127            depth.increment()?;
12128            let envelope_size = 8;
12129            let bytes_len = len * envelope_size;
12130            let offset = decoder.out_of_line_offset(bytes_len)?;
12131            // Decode the envelope for each type.
12132            let mut _next_ordinal_to_read = 0;
12133            let mut next_offset = offset;
12134            let end_offset = offset + bytes_len;
12135            _next_ordinal_to_read += 1;
12136            if next_offset >= end_offset {
12137                return Ok(());
12138            }
12139
12140            // Decode unknown envelopes for gaps in ordinals.
12141            while _next_ordinal_to_read < 1 {
12142                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12143                _next_ordinal_to_read += 1;
12144                next_offset += envelope_size;
12145            }
12146
12147            let next_out_of_line = decoder.next_out_of_line();
12148            let handles_before = decoder.remaining_handles();
12149            if let Some((inlined, num_bytes, num_handles)) =
12150                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12151            {
12152                let member_inline_size =
12153                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12154                if inlined != (member_inline_size <= 4) {
12155                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12156                }
12157                let inner_offset;
12158                let mut inner_depth = depth.clone();
12159                if inlined {
12160                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12161                    inner_offset = next_offset;
12162                } else {
12163                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12164                    inner_depth.increment()?;
12165                }
12166                let val_ref = self.fresh_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
12167                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12168                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12169                {
12170                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12171                }
12172                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12173                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12174                }
12175            }
12176
12177            next_offset += envelope_size;
12178            _next_ordinal_to_read += 1;
12179            if next_offset >= end_offset {
12180                return Ok(());
12181            }
12182
12183            // Decode unknown envelopes for gaps in ordinals.
12184            while _next_ordinal_to_read < 2 {
12185                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12186                _next_ordinal_to_read += 1;
12187                next_offset += envelope_size;
12188            }
12189
12190            let next_out_of_line = decoder.next_out_of_line();
12191            let handles_before = decoder.remaining_handles();
12192            if let Some((inlined, num_bytes, num_handles)) =
12193                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12194            {
12195                let member_inline_size =
12196                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12197                if inlined != (member_inline_size <= 4) {
12198                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12199                }
12200                let inner_offset;
12201                let mut inner_depth = depth.clone();
12202                if inlined {
12203                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12204                    inner_offset = next_offset;
12205                } else {
12206                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12207                    inner_depth.increment()?;
12208                }
12209                let val_ref = self.deleted_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
12210                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12211                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12212                {
12213                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12214                }
12215                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12216                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12217                }
12218            }
12219
12220            next_offset += envelope_size;
12221            _next_ordinal_to_read += 1;
12222            if next_offset >= end_offset {
12223                return Ok(());
12224            }
12225
12226            // Decode unknown envelopes for gaps in ordinals.
12227            while _next_ordinal_to_read < 3 {
12228                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12229                _next_ordinal_to_read += 1;
12230                next_offset += envelope_size;
12231            }
12232
12233            let next_out_of_line = decoder.next_out_of_line();
12234            let handles_before = decoder.remaining_handles();
12235            if let Some((inlined, num_bytes, num_handles)) =
12236                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12237            {
12238                let member_inline_size =
12239                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12240                if inlined != (member_inline_size <= 4) {
12241                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12242                }
12243                let inner_offset;
12244                let mut inner_depth = depth.clone();
12245                if inlined {
12246                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12247                    inner_offset = next_offset;
12248                } else {
12249                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12250                    inner_depth.increment()?;
12251                }
12252                let val_ref = self.lease_time_total.get_or_insert_with(|| fidl::new_empty!(i64, D));
12253                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
12254                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12255                {
12256                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12257                }
12258                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12259                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12260                }
12261            }
12262
12263            next_offset += envelope_size;
12264            _next_ordinal_to_read += 1;
12265            if next_offset >= end_offset {
12266                return Ok(());
12267            }
12268
12269            // Decode unknown envelopes for gaps in ordinals.
12270            while _next_ordinal_to_read < 4 {
12271                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12272                _next_ordinal_to_read += 1;
12273                next_offset += envelope_size;
12274            }
12275
12276            let next_out_of_line = decoder.next_out_of_line();
12277            let handles_before = decoder.remaining_handles();
12278            if let Some((inlined, num_bytes, num_handles)) =
12279                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12280            {
12281                let member_inline_size =
12282                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12283                if inlined != (member_inline_size <= 4) {
12284                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12285                }
12286                let inner_offset;
12287                let mut inner_depth = depth.clone();
12288                if inlined {
12289                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12290                    inner_offset = next_offset;
12291                } else {
12292                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12293                    inner_depth.increment()?;
12294                }
12295                let val_ref =
12296                    self.key_lease_time_total.get_or_insert_with(|| fidl::new_empty!(i64, D));
12297                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
12298                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12299                {
12300                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12301                }
12302                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12303                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12304                }
12305            }
12306
12307            next_offset += envelope_size;
12308            _next_ordinal_to_read += 1;
12309            if next_offset >= end_offset {
12310                return Ok(());
12311            }
12312
12313            // Decode unknown envelopes for gaps in ordinals.
12314            while _next_ordinal_to_read < 5 {
12315                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12316                _next_ordinal_to_read += 1;
12317                next_offset += envelope_size;
12318            }
12319
12320            let next_out_of_line = decoder.next_out_of_line();
12321            let handles_before = decoder.remaining_handles();
12322            if let Some((inlined, num_bytes, num_handles)) =
12323                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12324            {
12325                let member_inline_size =
12326                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12327                if inlined != (member_inline_size <= 4) {
12328                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12329                }
12330                let inner_offset;
12331                let mut inner_depth = depth.clone();
12332                if inlined {
12333                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12334                    inner_offset = next_offset;
12335                } else {
12336                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12337                    inner_depth.increment()?;
12338                }
12339                let val_ref =
12340                    self.remaining_lease_time_total.get_or_insert_with(|| fidl::new_empty!(i64, D));
12341                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
12342                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12343                {
12344                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12345                }
12346                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12347                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12348                }
12349            }
12350
12351            next_offset += envelope_size;
12352            _next_ordinal_to_read += 1;
12353            if next_offset >= end_offset {
12354                return Ok(());
12355            }
12356
12357            // Decode unknown envelopes for gaps in ordinals.
12358            while _next_ordinal_to_read < 6 {
12359                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12360                _next_ordinal_to_read += 1;
12361                next_offset += envelope_size;
12362            }
12363
12364            let next_out_of_line = decoder.next_out_of_line();
12365            let handles_before = decoder.remaining_handles();
12366            if let Some((inlined, num_bytes, num_handles)) =
12367                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12368            {
12369                let member_inline_size =
12370                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12371                if inlined != (member_inline_size <= 4) {
12372                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12373                }
12374                let inner_offset;
12375                let mut inner_depth = depth.clone();
12376                if inlined {
12377                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12378                    inner_offset = next_offset;
12379                } else {
12380                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12381                    inner_depth.increment()?;
12382                }
12383                let val_ref = self
12384                    .remaining_key_lease_time_total
12385                    .get_or_insert_with(|| fidl::new_empty!(i64, D));
12386                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
12387                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12388                {
12389                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12390                }
12391                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12392                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12393                }
12394            }
12395
12396            next_offset += envelope_size;
12397
12398            // Decode the remaining unknown envelopes.
12399            while next_offset < end_offset {
12400                _next_ordinal_to_read += 1;
12401                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12402                next_offset += envelope_size;
12403            }
12404
12405            Ok(())
12406        }
12407    }
12408
12409    impl SrpServerResponseCounters {
12410        #[inline(always)]
12411        fn max_ordinal_present(&self) -> u64 {
12412            if let Some(_) = self.other_response {
12413                return 6;
12414            }
12415            if let Some(_) = self.refused_response {
12416                return 5;
12417            }
12418            if let Some(_) = self.name_exists_response {
12419                return 4;
12420            }
12421            if let Some(_) = self.format_error_response {
12422                return 3;
12423            }
12424            if let Some(_) = self.server_failure_response {
12425                return 2;
12426            }
12427            if let Some(_) = self.success_response {
12428                return 1;
12429            }
12430            0
12431        }
12432    }
12433
12434    impl fidl::encoding::ValueTypeMarker for SrpServerResponseCounters {
12435        type Borrowed<'a> = &'a Self;
12436        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12437            value
12438        }
12439    }
12440
12441    unsafe impl fidl::encoding::TypeMarker for SrpServerResponseCounters {
12442        type Owned = Self;
12443
12444        #[inline(always)]
12445        fn inline_align(_context: fidl::encoding::Context) -> usize {
12446            8
12447        }
12448
12449        #[inline(always)]
12450        fn inline_size(_context: fidl::encoding::Context) -> usize {
12451            16
12452        }
12453    }
12454
12455    unsafe impl<D: fidl::encoding::ResourceDialect>
12456        fidl::encoding::Encode<SrpServerResponseCounters, D> for &SrpServerResponseCounters
12457    {
12458        unsafe fn encode(
12459            self,
12460            encoder: &mut fidl::encoding::Encoder<'_, D>,
12461            offset: usize,
12462            mut depth: fidl::encoding::Depth,
12463        ) -> fidl::Result<()> {
12464            encoder.debug_check_bounds::<SrpServerResponseCounters>(offset);
12465            // Vector header
12466            let max_ordinal: u64 = self.max_ordinal_present();
12467            encoder.write_num(max_ordinal, offset);
12468            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12469            // Calling encoder.out_of_line_offset(0) is not allowed.
12470            if max_ordinal == 0 {
12471                return Ok(());
12472            }
12473            depth.increment()?;
12474            let envelope_size = 8;
12475            let bytes_len = max_ordinal as usize * envelope_size;
12476            #[allow(unused_variables)]
12477            let offset = encoder.out_of_line_offset(bytes_len);
12478            let mut _prev_end_offset: usize = 0;
12479            if 1 > max_ordinal {
12480                return Ok(());
12481            }
12482
12483            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12484            // are envelope_size bytes.
12485            let cur_offset: usize = (1 - 1) * envelope_size;
12486
12487            // Zero reserved fields.
12488            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12489
12490            // Safety:
12491            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12492            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12493            //   envelope_size bytes, there is always sufficient room.
12494            fidl::encoding::encode_in_envelope_optional::<u32, D>(
12495                self.success_response
12496                    .as_ref()
12497                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12498                encoder,
12499                offset + cur_offset,
12500                depth,
12501            )?;
12502
12503            _prev_end_offset = cur_offset + envelope_size;
12504            if 2 > max_ordinal {
12505                return Ok(());
12506            }
12507
12508            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12509            // are envelope_size bytes.
12510            let cur_offset: usize = (2 - 1) * envelope_size;
12511
12512            // Zero reserved fields.
12513            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12514
12515            // Safety:
12516            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12517            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12518            //   envelope_size bytes, there is always sufficient room.
12519            fidl::encoding::encode_in_envelope_optional::<u32, D>(
12520                self.server_failure_response
12521                    .as_ref()
12522                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12523                encoder,
12524                offset + cur_offset,
12525                depth,
12526            )?;
12527
12528            _prev_end_offset = cur_offset + envelope_size;
12529            if 3 > max_ordinal {
12530                return Ok(());
12531            }
12532
12533            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12534            // are envelope_size bytes.
12535            let cur_offset: usize = (3 - 1) * envelope_size;
12536
12537            // Zero reserved fields.
12538            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12539
12540            // Safety:
12541            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12542            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12543            //   envelope_size bytes, there is always sufficient room.
12544            fidl::encoding::encode_in_envelope_optional::<u32, D>(
12545                self.format_error_response
12546                    .as_ref()
12547                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12548                encoder,
12549                offset + cur_offset,
12550                depth,
12551            )?;
12552
12553            _prev_end_offset = cur_offset + envelope_size;
12554            if 4 > max_ordinal {
12555                return Ok(());
12556            }
12557
12558            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12559            // are envelope_size bytes.
12560            let cur_offset: usize = (4 - 1) * envelope_size;
12561
12562            // Zero reserved fields.
12563            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12564
12565            // Safety:
12566            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12567            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12568            //   envelope_size bytes, there is always sufficient room.
12569            fidl::encoding::encode_in_envelope_optional::<u32, D>(
12570                self.name_exists_response
12571                    .as_ref()
12572                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12573                encoder,
12574                offset + cur_offset,
12575                depth,
12576            )?;
12577
12578            _prev_end_offset = cur_offset + envelope_size;
12579            if 5 > max_ordinal {
12580                return Ok(());
12581            }
12582
12583            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12584            // are envelope_size bytes.
12585            let cur_offset: usize = (5 - 1) * envelope_size;
12586
12587            // Zero reserved fields.
12588            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12589
12590            // Safety:
12591            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12592            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12593            //   envelope_size bytes, there is always sufficient room.
12594            fidl::encoding::encode_in_envelope_optional::<u32, D>(
12595                self.refused_response
12596                    .as_ref()
12597                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12598                encoder,
12599                offset + cur_offset,
12600                depth,
12601            )?;
12602
12603            _prev_end_offset = cur_offset + envelope_size;
12604            if 6 > max_ordinal {
12605                return Ok(());
12606            }
12607
12608            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12609            // are envelope_size bytes.
12610            let cur_offset: usize = (6 - 1) * envelope_size;
12611
12612            // Zero reserved fields.
12613            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12614
12615            // Safety:
12616            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12617            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12618            //   envelope_size bytes, there is always sufficient room.
12619            fidl::encoding::encode_in_envelope_optional::<u32, D>(
12620                self.other_response.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12621                encoder,
12622                offset + cur_offset,
12623                depth,
12624            )?;
12625
12626            _prev_end_offset = cur_offset + envelope_size;
12627
12628            Ok(())
12629        }
12630    }
12631
12632    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12633        for SrpServerResponseCounters
12634    {
12635        #[inline(always)]
12636        fn new_empty() -> Self {
12637            Self::default()
12638        }
12639
12640        unsafe fn decode(
12641            &mut self,
12642            decoder: &mut fidl::encoding::Decoder<'_, D>,
12643            offset: usize,
12644            mut depth: fidl::encoding::Depth,
12645        ) -> fidl::Result<()> {
12646            decoder.debug_check_bounds::<Self>(offset);
12647            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12648                None => return Err(fidl::Error::NotNullable),
12649                Some(len) => len,
12650            };
12651            // Calling decoder.out_of_line_offset(0) is not allowed.
12652            if len == 0 {
12653                return Ok(());
12654            };
12655            depth.increment()?;
12656            let envelope_size = 8;
12657            let bytes_len = len * envelope_size;
12658            let offset = decoder.out_of_line_offset(bytes_len)?;
12659            // Decode the envelope for each type.
12660            let mut _next_ordinal_to_read = 0;
12661            let mut next_offset = offset;
12662            let end_offset = offset + bytes_len;
12663            _next_ordinal_to_read += 1;
12664            if next_offset >= end_offset {
12665                return Ok(());
12666            }
12667
12668            // Decode unknown envelopes for gaps in ordinals.
12669            while _next_ordinal_to_read < 1 {
12670                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12671                _next_ordinal_to_read += 1;
12672                next_offset += envelope_size;
12673            }
12674
12675            let next_out_of_line = decoder.next_out_of_line();
12676            let handles_before = decoder.remaining_handles();
12677            if let Some((inlined, num_bytes, num_handles)) =
12678                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12679            {
12680                let member_inline_size =
12681                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12682                if inlined != (member_inline_size <= 4) {
12683                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12684                }
12685                let inner_offset;
12686                let mut inner_depth = depth.clone();
12687                if inlined {
12688                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12689                    inner_offset = next_offset;
12690                } else {
12691                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12692                    inner_depth.increment()?;
12693                }
12694                let val_ref = self.success_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12695                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12696                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12697                {
12698                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12699                }
12700                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12701                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12702                }
12703            }
12704
12705            next_offset += envelope_size;
12706            _next_ordinal_to_read += 1;
12707            if next_offset >= end_offset {
12708                return Ok(());
12709            }
12710
12711            // Decode unknown envelopes for gaps in ordinals.
12712            while _next_ordinal_to_read < 2 {
12713                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12714                _next_ordinal_to_read += 1;
12715                next_offset += envelope_size;
12716            }
12717
12718            let next_out_of_line = decoder.next_out_of_line();
12719            let handles_before = decoder.remaining_handles();
12720            if let Some((inlined, num_bytes, num_handles)) =
12721                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12722            {
12723                let member_inline_size =
12724                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12725                if inlined != (member_inline_size <= 4) {
12726                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12727                }
12728                let inner_offset;
12729                let mut inner_depth = depth.clone();
12730                if inlined {
12731                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12732                    inner_offset = next_offset;
12733                } else {
12734                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12735                    inner_depth.increment()?;
12736                }
12737                let val_ref =
12738                    self.server_failure_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12739                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12740                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12741                {
12742                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12743                }
12744                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12745                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12746                }
12747            }
12748
12749            next_offset += envelope_size;
12750            _next_ordinal_to_read += 1;
12751            if next_offset >= end_offset {
12752                return Ok(());
12753            }
12754
12755            // Decode unknown envelopes for gaps in ordinals.
12756            while _next_ordinal_to_read < 3 {
12757                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12758                _next_ordinal_to_read += 1;
12759                next_offset += envelope_size;
12760            }
12761
12762            let next_out_of_line = decoder.next_out_of_line();
12763            let handles_before = decoder.remaining_handles();
12764            if let Some((inlined, num_bytes, num_handles)) =
12765                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12766            {
12767                let member_inline_size =
12768                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12769                if inlined != (member_inline_size <= 4) {
12770                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12771                }
12772                let inner_offset;
12773                let mut inner_depth = depth.clone();
12774                if inlined {
12775                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12776                    inner_offset = next_offset;
12777                } else {
12778                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12779                    inner_depth.increment()?;
12780                }
12781                let val_ref =
12782                    self.format_error_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12783                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12784                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12785                {
12786                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12787                }
12788                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12789                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12790                }
12791            }
12792
12793            next_offset += envelope_size;
12794            _next_ordinal_to_read += 1;
12795            if next_offset >= end_offset {
12796                return Ok(());
12797            }
12798
12799            // Decode unknown envelopes for gaps in ordinals.
12800            while _next_ordinal_to_read < 4 {
12801                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12802                _next_ordinal_to_read += 1;
12803                next_offset += envelope_size;
12804            }
12805
12806            let next_out_of_line = decoder.next_out_of_line();
12807            let handles_before = decoder.remaining_handles();
12808            if let Some((inlined, num_bytes, num_handles)) =
12809                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12810            {
12811                let member_inline_size =
12812                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12813                if inlined != (member_inline_size <= 4) {
12814                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12815                }
12816                let inner_offset;
12817                let mut inner_depth = depth.clone();
12818                if inlined {
12819                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12820                    inner_offset = next_offset;
12821                } else {
12822                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12823                    inner_depth.increment()?;
12824                }
12825                let val_ref =
12826                    self.name_exists_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12827                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12828                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12829                {
12830                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12831                }
12832                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12833                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12834                }
12835            }
12836
12837            next_offset += envelope_size;
12838            _next_ordinal_to_read += 1;
12839            if next_offset >= end_offset {
12840                return Ok(());
12841            }
12842
12843            // Decode unknown envelopes for gaps in ordinals.
12844            while _next_ordinal_to_read < 5 {
12845                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12846                _next_ordinal_to_read += 1;
12847                next_offset += envelope_size;
12848            }
12849
12850            let next_out_of_line = decoder.next_out_of_line();
12851            let handles_before = decoder.remaining_handles();
12852            if let Some((inlined, num_bytes, num_handles)) =
12853                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12854            {
12855                let member_inline_size =
12856                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12857                if inlined != (member_inline_size <= 4) {
12858                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12859                }
12860                let inner_offset;
12861                let mut inner_depth = depth.clone();
12862                if inlined {
12863                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12864                    inner_offset = next_offset;
12865                } else {
12866                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12867                    inner_depth.increment()?;
12868                }
12869                let val_ref = self.refused_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12870                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12871                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12872                {
12873                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12874                }
12875                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12876                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12877                }
12878            }
12879
12880            next_offset += envelope_size;
12881            _next_ordinal_to_read += 1;
12882            if next_offset >= end_offset {
12883                return Ok(());
12884            }
12885
12886            // Decode unknown envelopes for gaps in ordinals.
12887            while _next_ordinal_to_read < 6 {
12888                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12889                _next_ordinal_to_read += 1;
12890                next_offset += envelope_size;
12891            }
12892
12893            let next_out_of_line = decoder.next_out_of_line();
12894            let handles_before = decoder.remaining_handles();
12895            if let Some((inlined, num_bytes, num_handles)) =
12896                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12897            {
12898                let member_inline_size =
12899                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12900                if inlined != (member_inline_size <= 4) {
12901                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12902                }
12903                let inner_offset;
12904                let mut inner_depth = depth.clone();
12905                if inlined {
12906                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12907                    inner_offset = next_offset;
12908                } else {
12909                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12910                    inner_depth.increment()?;
12911                }
12912                let val_ref = self.other_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12913                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12914                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12915                {
12916                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12917                }
12918                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12919                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12920                }
12921            }
12922
12923            next_offset += envelope_size;
12924
12925            // Decode the remaining unknown envelopes.
12926            while next_offset < end_offset {
12927                _next_ordinal_to_read += 1;
12928                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12929                next_offset += envelope_size;
12930            }
12931
12932            Ok(())
12933        }
12934    }
12935
12936    impl Telemetry {
12937        #[inline(always)]
12938        fn max_ordinal_present(&self) -> u64 {
12939            if let Some(_) = self.link_metrics_entries {
12940                return 24;
12941            }
12942            if let Some(_) = self.dhcp6pd_info {
12943                return 23;
12944            }
12945            if let Some(_) = self.upstream_dns_info {
12946                return 22;
12947            }
12948            if let Some(_) = self.trel_peers_info {
12949                return 21;
12950            }
12951            if let Some(_) = self.trel_counters {
12952                return 20;
12953            }
12954            if let Some(_) = self.nat64_info {
12955                return 19;
12956            }
12957            if let Some(_) = self.uptime {
12958                return 18;
12959            }
12960            if let Some(_) = self.leader_data {
12961                return 17;
12962            }
12963            if let Some(_) = self.dnssd_counters {
12964                return 16;
12965            }
12966            if let Some(_) = self.srp_server_info {
12967                return 15;
12968            }
12969            if let Some(_) = self.thread_border_routing_counters {
12970                return 14;
12971            }
12972            if let Some(_) = self.thread_stable_network_data {
12973                return 13;
12974            }
12975            if let Some(_) = self.thread_network_data {
12976                return 12;
12977            }
12978            if let Some(_) = self.thread_stable_network_data_version {
12979                return 11;
12980            }
12981            if let Some(_) = self.thread_network_data_version {
12982                return 10;
12983            }
12984            if let Some(_) = self.thread_rloc {
12985                return 9;
12986            }
12987            if let Some(_) = self.thread_router_id {
12988                return 8;
12989            }
12990            if let Some(_) = self.thread_link_mode {
12991                return 7;
12992            }
12993            if let Some(_) = self.rcp_version {
12994                return 6;
12995            }
12996            if let Some(_) = self.stack_version {
12997                return 5;
12998            }
12999            if let Some(_) = self.partition_id {
13000                return 4;
13001            }
13002            if let Some(_) = self.channel_index {
13003                return 3;
13004            }
13005            if let Some(_) = self.tx_power {
13006                return 2;
13007            }
13008            if let Some(_) = self.rssi {
13009                return 1;
13010            }
13011            0
13012        }
13013    }
13014
13015    impl fidl::encoding::ValueTypeMarker for Telemetry {
13016        type Borrowed<'a> = &'a Self;
13017        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13018            value
13019        }
13020    }
13021
13022    unsafe impl fidl::encoding::TypeMarker for Telemetry {
13023        type Owned = Self;
13024
13025        #[inline(always)]
13026        fn inline_align(_context: fidl::encoding::Context) -> usize {
13027            8
13028        }
13029
13030        #[inline(always)]
13031        fn inline_size(_context: fidl::encoding::Context) -> usize {
13032            16
13033        }
13034    }
13035
13036    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Telemetry, D>
13037        for &Telemetry
13038    {
13039        unsafe fn encode(
13040            self,
13041            encoder: &mut fidl::encoding::Encoder<'_, D>,
13042            offset: usize,
13043            mut depth: fidl::encoding::Depth,
13044        ) -> fidl::Result<()> {
13045            encoder.debug_check_bounds::<Telemetry>(offset);
13046            // Vector header
13047            let max_ordinal: u64 = self.max_ordinal_present();
13048            encoder.write_num(max_ordinal, offset);
13049            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13050            // Calling encoder.out_of_line_offset(0) is not allowed.
13051            if max_ordinal == 0 {
13052                return Ok(());
13053            }
13054            depth.increment()?;
13055            let envelope_size = 8;
13056            let bytes_len = max_ordinal as usize * envelope_size;
13057            #[allow(unused_variables)]
13058            let offset = encoder.out_of_line_offset(bytes_len);
13059            let mut _prev_end_offset: usize = 0;
13060            if 1 > max_ordinal {
13061                return Ok(());
13062            }
13063
13064            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13065            // are envelope_size bytes.
13066            let cur_offset: usize = (1 - 1) * envelope_size;
13067
13068            // Zero reserved fields.
13069            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13070
13071            // Safety:
13072            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13073            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13074            //   envelope_size bytes, there is always sufficient room.
13075            fidl::encoding::encode_in_envelope_optional::<i8, D>(
13076                self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
13077                encoder,
13078                offset + cur_offset,
13079                depth,
13080            )?;
13081
13082            _prev_end_offset = cur_offset + envelope_size;
13083            if 2 > max_ordinal {
13084                return Ok(());
13085            }
13086
13087            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13088            // are envelope_size bytes.
13089            let cur_offset: usize = (2 - 1) * envelope_size;
13090
13091            // Zero reserved fields.
13092            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13093
13094            // Safety:
13095            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13096            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13097            //   envelope_size bytes, there is always sufficient room.
13098            fidl::encoding::encode_in_envelope_optional::<i8, D>(
13099                self.tx_power.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
13100                encoder,
13101                offset + cur_offset,
13102                depth,
13103            )?;
13104
13105            _prev_end_offset = cur_offset + envelope_size;
13106            if 3 > max_ordinal {
13107                return Ok(());
13108            }
13109
13110            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13111            // are envelope_size bytes.
13112            let cur_offset: usize = (3 - 1) * envelope_size;
13113
13114            // Zero reserved fields.
13115            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13116
13117            // Safety:
13118            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13119            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13120            //   envelope_size bytes, there is always sufficient room.
13121            fidl::encoding::encode_in_envelope_optional::<u16, D>(
13122                self.channel_index.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
13123                encoder,
13124                offset + cur_offset,
13125                depth,
13126            )?;
13127
13128            _prev_end_offset = cur_offset + envelope_size;
13129            if 4 > max_ordinal {
13130                return Ok(());
13131            }
13132
13133            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13134            // are envelope_size bytes.
13135            let cur_offset: usize = (4 - 1) * envelope_size;
13136
13137            // Zero reserved fields.
13138            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13139
13140            // Safety:
13141            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13142            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13143            //   envelope_size bytes, there is always sufficient room.
13144            fidl::encoding::encode_in_envelope_optional::<u32, D>(
13145                self.partition_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
13146                encoder,
13147                offset + cur_offset,
13148                depth,
13149            )?;
13150
13151            _prev_end_offset = cur_offset + envelope_size;
13152            if 5 > max_ordinal {
13153                return Ok(());
13154            }
13155
13156            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13157            // are envelope_size bytes.
13158            let cur_offset: usize = (5 - 1) * envelope_size;
13159
13160            // Zero reserved fields.
13161            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13162
13163            // Safety:
13164            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13165            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13166            //   envelope_size bytes, there is always sufficient room.
13167            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
13168                self.stack_version.as_ref().map(
13169                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
13170                ),
13171                encoder,
13172                offset + cur_offset,
13173                depth,
13174            )?;
13175
13176            _prev_end_offset = cur_offset + envelope_size;
13177            if 6 > max_ordinal {
13178                return Ok(());
13179            }
13180
13181            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13182            // are envelope_size bytes.
13183            let cur_offset: usize = (6 - 1) * envelope_size;
13184
13185            // Zero reserved fields.
13186            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13187
13188            // Safety:
13189            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13190            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13191            //   envelope_size bytes, there is always sufficient room.
13192            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
13193                self.rcp_version.as_ref().map(
13194                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
13195                ),
13196                encoder,
13197                offset + cur_offset,
13198                depth,
13199            )?;
13200
13201            _prev_end_offset = cur_offset + envelope_size;
13202            if 7 > max_ordinal {
13203                return Ok(());
13204            }
13205
13206            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13207            // are envelope_size bytes.
13208            let cur_offset: usize = (7 - 1) * envelope_size;
13209
13210            // Zero reserved fields.
13211            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13212
13213            // Safety:
13214            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13215            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13216            //   envelope_size bytes, there is always sufficient room.
13217            fidl::encoding::encode_in_envelope_optional::<u8, D>(
13218                self.thread_link_mode.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
13219                encoder,
13220                offset + cur_offset,
13221                depth,
13222            )?;
13223
13224            _prev_end_offset = cur_offset + envelope_size;
13225            if 8 > max_ordinal {
13226                return Ok(());
13227            }
13228
13229            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13230            // are envelope_size bytes.
13231            let cur_offset: usize = (8 - 1) * envelope_size;
13232
13233            // Zero reserved fields.
13234            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13235
13236            // Safety:
13237            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13238            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13239            //   envelope_size bytes, there is always sufficient room.
13240            fidl::encoding::encode_in_envelope_optional::<u8, D>(
13241                self.thread_router_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
13242                encoder,
13243                offset + cur_offset,
13244                depth,
13245            )?;
13246
13247            _prev_end_offset = cur_offset + envelope_size;
13248            if 9 > max_ordinal {
13249                return Ok(());
13250            }
13251
13252            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13253            // are envelope_size bytes.
13254            let cur_offset: usize = (9 - 1) * envelope_size;
13255
13256            // Zero reserved fields.
13257            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13258
13259            // Safety:
13260            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13261            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13262            //   envelope_size bytes, there is always sufficient room.
13263            fidl::encoding::encode_in_envelope_optional::<u16, D>(
13264                self.thread_rloc.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
13265                encoder,
13266                offset + cur_offset,
13267                depth,
13268            )?;
13269
13270            _prev_end_offset = cur_offset + envelope_size;
13271            if 10 > max_ordinal {
13272                return Ok(());
13273            }
13274
13275            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13276            // are envelope_size bytes.
13277            let cur_offset: usize = (10 - 1) * envelope_size;
13278
13279            // Zero reserved fields.
13280            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13281
13282            // Safety:
13283            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13284            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13285            //   envelope_size bytes, there is always sufficient room.
13286            fidl::encoding::encode_in_envelope_optional::<u8, D>(
13287                self.thread_network_data_version
13288                    .as_ref()
13289                    .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
13290                encoder,
13291                offset + cur_offset,
13292                depth,
13293            )?;
13294
13295            _prev_end_offset = cur_offset + envelope_size;
13296            if 11 > max_ordinal {
13297                return Ok(());
13298            }
13299
13300            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13301            // are envelope_size bytes.
13302            let cur_offset: usize = (11 - 1) * envelope_size;
13303
13304            // Zero reserved fields.
13305            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13306
13307            // Safety:
13308            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13309            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13310            //   envelope_size bytes, there is always sufficient room.
13311            fidl::encoding::encode_in_envelope_optional::<u8, D>(
13312                self.thread_stable_network_data_version
13313                    .as_ref()
13314                    .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
13315                encoder,
13316                offset + cur_offset,
13317                depth,
13318            )?;
13319
13320            _prev_end_offset = cur_offset + envelope_size;
13321            if 12 > max_ordinal {
13322                return Ok(());
13323            }
13324
13325            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13326            // are envelope_size bytes.
13327            let cur_offset: usize = (12 - 1) * envelope_size;
13328
13329            // Zero reserved fields.
13330            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13331
13332            // Safety:
13333            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13334            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13335            //   envelope_size bytes, there is always sufficient room.
13336            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 255>, D>(
13337                self.thread_network_data.as_ref().map(
13338                    <fidl::encoding::Vector<u8, 255> as fidl::encoding::ValueTypeMarker>::borrow,
13339                ),
13340                encoder,
13341                offset + cur_offset,
13342                depth,
13343            )?;
13344
13345            _prev_end_offset = cur_offset + envelope_size;
13346            if 13 > max_ordinal {
13347                return Ok(());
13348            }
13349
13350            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13351            // are envelope_size bytes.
13352            let cur_offset: usize = (13 - 1) * envelope_size;
13353
13354            // Zero reserved fields.
13355            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13356
13357            // Safety:
13358            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13359            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13360            //   envelope_size bytes, there is always sufficient room.
13361            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 255>, D>(
13362                self.thread_stable_network_data.as_ref().map(
13363                    <fidl::encoding::Vector<u8, 255> as fidl::encoding::ValueTypeMarker>::borrow,
13364                ),
13365                encoder,
13366                offset + cur_offset,
13367                depth,
13368            )?;
13369
13370            _prev_end_offset = cur_offset + envelope_size;
13371            if 14 > max_ordinal {
13372                return Ok(());
13373            }
13374
13375            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13376            // are envelope_size bytes.
13377            let cur_offset: usize = (14 - 1) * envelope_size;
13378
13379            // Zero reserved fields.
13380            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13381
13382            // Safety:
13383            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13384            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13385            //   envelope_size bytes, there is always sufficient room.
13386            fidl::encoding::encode_in_envelope_optional::<BorderRoutingCounters, D>(
13387                self.thread_border_routing_counters
13388                    .as_ref()
13389                    .map(<BorderRoutingCounters as fidl::encoding::ValueTypeMarker>::borrow),
13390                encoder,
13391                offset + cur_offset,
13392                depth,
13393            )?;
13394
13395            _prev_end_offset = cur_offset + envelope_size;
13396            if 15 > max_ordinal {
13397                return Ok(());
13398            }
13399
13400            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13401            // are envelope_size bytes.
13402            let cur_offset: usize = (15 - 1) * envelope_size;
13403
13404            // Zero reserved fields.
13405            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13406
13407            // Safety:
13408            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13409            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13410            //   envelope_size bytes, there is always sufficient room.
13411            fidl::encoding::encode_in_envelope_optional::<SrpServerInfo, D>(
13412                self.srp_server_info
13413                    .as_ref()
13414                    .map(<SrpServerInfo as fidl::encoding::ValueTypeMarker>::borrow),
13415                encoder,
13416                offset + cur_offset,
13417                depth,
13418            )?;
13419
13420            _prev_end_offset = cur_offset + envelope_size;
13421            if 16 > max_ordinal {
13422                return Ok(());
13423            }
13424
13425            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13426            // are envelope_size bytes.
13427            let cur_offset: usize = (16 - 1) * envelope_size;
13428
13429            // Zero reserved fields.
13430            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13431
13432            // Safety:
13433            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13434            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13435            //   envelope_size bytes, there is always sufficient room.
13436            fidl::encoding::encode_in_envelope_optional::<DnssdCounters, D>(
13437                self.dnssd_counters
13438                    .as_ref()
13439                    .map(<DnssdCounters as fidl::encoding::ValueTypeMarker>::borrow),
13440                encoder,
13441                offset + cur_offset,
13442                depth,
13443            )?;
13444
13445            _prev_end_offset = cur_offset + envelope_size;
13446            if 17 > max_ordinal {
13447                return Ok(());
13448            }
13449
13450            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13451            // are envelope_size bytes.
13452            let cur_offset: usize = (17 - 1) * envelope_size;
13453
13454            // Zero reserved fields.
13455            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13456
13457            // Safety:
13458            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13459            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13460            //   envelope_size bytes, there is always sufficient room.
13461            fidl::encoding::encode_in_envelope_optional::<LeaderData, D>(
13462                self.leader_data
13463                    .as_ref()
13464                    .map(<LeaderData as fidl::encoding::ValueTypeMarker>::borrow),
13465                encoder,
13466                offset + cur_offset,
13467                depth,
13468            )?;
13469
13470            _prev_end_offset = cur_offset + envelope_size;
13471            if 18 > max_ordinal {
13472                return Ok(());
13473            }
13474
13475            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13476            // are envelope_size bytes.
13477            let cur_offset: usize = (18 - 1) * envelope_size;
13478
13479            // Zero reserved fields.
13480            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13481
13482            // Safety:
13483            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13484            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13485            //   envelope_size bytes, there is always sufficient room.
13486            fidl::encoding::encode_in_envelope_optional::<i64, D>(
13487                self.uptime.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
13488                encoder,
13489                offset + cur_offset,
13490                depth,
13491            )?;
13492
13493            _prev_end_offset = cur_offset + envelope_size;
13494            if 19 > max_ordinal {
13495                return Ok(());
13496            }
13497
13498            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13499            // are envelope_size bytes.
13500            let cur_offset: usize = (19 - 1) * envelope_size;
13501
13502            // Zero reserved fields.
13503            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13504
13505            // Safety:
13506            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13507            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13508            //   envelope_size bytes, there is always sufficient room.
13509            fidl::encoding::encode_in_envelope_optional::<Nat64Info, D>(
13510                self.nat64_info
13511                    .as_ref()
13512                    .map(<Nat64Info as fidl::encoding::ValueTypeMarker>::borrow),
13513                encoder,
13514                offset + cur_offset,
13515                depth,
13516            )?;
13517
13518            _prev_end_offset = cur_offset + envelope_size;
13519            if 20 > max_ordinal {
13520                return Ok(());
13521            }
13522
13523            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13524            // are envelope_size bytes.
13525            let cur_offset: usize = (20 - 1) * envelope_size;
13526
13527            // Zero reserved fields.
13528            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13529
13530            // Safety:
13531            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13532            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13533            //   envelope_size bytes, there is always sufficient room.
13534            fidl::encoding::encode_in_envelope_optional::<TrelCounters, D>(
13535                self.trel_counters
13536                    .as_ref()
13537                    .map(<TrelCounters as fidl::encoding::ValueTypeMarker>::borrow),
13538                encoder,
13539                offset + cur_offset,
13540                depth,
13541            )?;
13542
13543            _prev_end_offset = cur_offset + envelope_size;
13544            if 21 > max_ordinal {
13545                return Ok(());
13546            }
13547
13548            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13549            // are envelope_size bytes.
13550            let cur_offset: usize = (21 - 1) * envelope_size;
13551
13552            // Zero reserved fields.
13553            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13554
13555            // Safety:
13556            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13557            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13558            //   envelope_size bytes, there is always sufficient room.
13559            fidl::encoding::encode_in_envelope_optional::<TrelPeersInfo, D>(
13560                self.trel_peers_info
13561                    .as_ref()
13562                    .map(<TrelPeersInfo as fidl::encoding::ValueTypeMarker>::borrow),
13563                encoder,
13564                offset + cur_offset,
13565                depth,
13566            )?;
13567
13568            _prev_end_offset = cur_offset + envelope_size;
13569            if 22 > max_ordinal {
13570                return Ok(());
13571            }
13572
13573            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13574            // are envelope_size bytes.
13575            let cur_offset: usize = (22 - 1) * envelope_size;
13576
13577            // Zero reserved fields.
13578            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13579
13580            // Safety:
13581            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13582            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13583            //   envelope_size bytes, there is always sufficient room.
13584            fidl::encoding::encode_in_envelope_optional::<UpstreamDnsInfo, D>(
13585                self.upstream_dns_info
13586                    .as_ref()
13587                    .map(<UpstreamDnsInfo as fidl::encoding::ValueTypeMarker>::borrow),
13588                encoder,
13589                offset + cur_offset,
13590                depth,
13591            )?;
13592
13593            _prev_end_offset = cur_offset + envelope_size;
13594            if 23 > max_ordinal {
13595                return Ok(());
13596            }
13597
13598            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13599            // are envelope_size bytes.
13600            let cur_offset: usize = (23 - 1) * envelope_size;
13601
13602            // Zero reserved fields.
13603            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13604
13605            // Safety:
13606            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13607            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13608            //   envelope_size bytes, there is always sufficient room.
13609            fidl::encoding::encode_in_envelope_optional::<Dhcp6PdInfo, D>(
13610                self.dhcp6pd_info
13611                    .as_ref()
13612                    .map(<Dhcp6PdInfo as fidl::encoding::ValueTypeMarker>::borrow),
13613                encoder,
13614                offset + cur_offset,
13615                depth,
13616            )?;
13617
13618            _prev_end_offset = cur_offset + envelope_size;
13619            if 24 > max_ordinal {
13620                return Ok(());
13621            }
13622
13623            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13624            // are envelope_size bytes.
13625            let cur_offset: usize = (24 - 1) * envelope_size;
13626
13627            // Zero reserved fields.
13628            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13629
13630            // Safety:
13631            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13632            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13633            //   envelope_size bytes, there is always sufficient room.
13634            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<LinkMetricsEntry, 64>, D>(
13635            self.link_metrics_entries.as_ref().map(<fidl::encoding::Vector<LinkMetricsEntry, 64> as fidl::encoding::ValueTypeMarker>::borrow),
13636            encoder, offset + cur_offset, depth
13637        )?;
13638
13639            _prev_end_offset = cur_offset + envelope_size;
13640
13641            Ok(())
13642        }
13643    }
13644
13645    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Telemetry {
13646        #[inline(always)]
13647        fn new_empty() -> Self {
13648            Self::default()
13649        }
13650
13651        unsafe fn decode(
13652            &mut self,
13653            decoder: &mut fidl::encoding::Decoder<'_, D>,
13654            offset: usize,
13655            mut depth: fidl::encoding::Depth,
13656        ) -> fidl::Result<()> {
13657            decoder.debug_check_bounds::<Self>(offset);
13658            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13659                None => return Err(fidl::Error::NotNullable),
13660                Some(len) => len,
13661            };
13662            // Calling decoder.out_of_line_offset(0) is not allowed.
13663            if len == 0 {
13664                return Ok(());
13665            };
13666            depth.increment()?;
13667            let envelope_size = 8;
13668            let bytes_len = len * envelope_size;
13669            let offset = decoder.out_of_line_offset(bytes_len)?;
13670            // Decode the envelope for each type.
13671            let mut _next_ordinal_to_read = 0;
13672            let mut next_offset = offset;
13673            let end_offset = offset + bytes_len;
13674            _next_ordinal_to_read += 1;
13675            if next_offset >= end_offset {
13676                return Ok(());
13677            }
13678
13679            // Decode unknown envelopes for gaps in ordinals.
13680            while _next_ordinal_to_read < 1 {
13681                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13682                _next_ordinal_to_read += 1;
13683                next_offset += envelope_size;
13684            }
13685
13686            let next_out_of_line = decoder.next_out_of_line();
13687            let handles_before = decoder.remaining_handles();
13688            if let Some((inlined, num_bytes, num_handles)) =
13689                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13690            {
13691                let member_inline_size =
13692                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13693                if inlined != (member_inline_size <= 4) {
13694                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13695                }
13696                let inner_offset;
13697                let mut inner_depth = depth.clone();
13698                if inlined {
13699                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13700                    inner_offset = next_offset;
13701                } else {
13702                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13703                    inner_depth.increment()?;
13704                }
13705                let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
13706                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
13707                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13708                {
13709                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13710                }
13711                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13712                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13713                }
13714            }
13715
13716            next_offset += envelope_size;
13717            _next_ordinal_to_read += 1;
13718            if next_offset >= end_offset {
13719                return Ok(());
13720            }
13721
13722            // Decode unknown envelopes for gaps in ordinals.
13723            while _next_ordinal_to_read < 2 {
13724                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13725                _next_ordinal_to_read += 1;
13726                next_offset += envelope_size;
13727            }
13728
13729            let next_out_of_line = decoder.next_out_of_line();
13730            let handles_before = decoder.remaining_handles();
13731            if let Some((inlined, num_bytes, num_handles)) =
13732                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13733            {
13734                let member_inline_size =
13735                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13736                if inlined != (member_inline_size <= 4) {
13737                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13738                }
13739                let inner_offset;
13740                let mut inner_depth = depth.clone();
13741                if inlined {
13742                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13743                    inner_offset = next_offset;
13744                } else {
13745                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13746                    inner_depth.increment()?;
13747                }
13748                let val_ref = self.tx_power.get_or_insert_with(|| fidl::new_empty!(i8, D));
13749                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
13750                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13751                {
13752                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13753                }
13754                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13755                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13756                }
13757            }
13758
13759            next_offset += envelope_size;
13760            _next_ordinal_to_read += 1;
13761            if next_offset >= end_offset {
13762                return Ok(());
13763            }
13764
13765            // Decode unknown envelopes for gaps in ordinals.
13766            while _next_ordinal_to_read < 3 {
13767                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13768                _next_ordinal_to_read += 1;
13769                next_offset += envelope_size;
13770            }
13771
13772            let next_out_of_line = decoder.next_out_of_line();
13773            let handles_before = decoder.remaining_handles();
13774            if let Some((inlined, num_bytes, num_handles)) =
13775                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13776            {
13777                let member_inline_size =
13778                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13779                if inlined != (member_inline_size <= 4) {
13780                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13781                }
13782                let inner_offset;
13783                let mut inner_depth = depth.clone();
13784                if inlined {
13785                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13786                    inner_offset = next_offset;
13787                } else {
13788                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13789                    inner_depth.increment()?;
13790                }
13791                let val_ref = self.channel_index.get_or_insert_with(|| fidl::new_empty!(u16, D));
13792                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
13793                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13794                {
13795                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13796                }
13797                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13798                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13799                }
13800            }
13801
13802            next_offset += envelope_size;
13803            _next_ordinal_to_read += 1;
13804            if next_offset >= end_offset {
13805                return Ok(());
13806            }
13807
13808            // Decode unknown envelopes for gaps in ordinals.
13809            while _next_ordinal_to_read < 4 {
13810                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13811                _next_ordinal_to_read += 1;
13812                next_offset += envelope_size;
13813            }
13814
13815            let next_out_of_line = decoder.next_out_of_line();
13816            let handles_before = decoder.remaining_handles();
13817            if let Some((inlined, num_bytes, num_handles)) =
13818                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13819            {
13820                let member_inline_size =
13821                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13822                if inlined != (member_inline_size <= 4) {
13823                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13824                }
13825                let inner_offset;
13826                let mut inner_depth = depth.clone();
13827                if inlined {
13828                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13829                    inner_offset = next_offset;
13830                } else {
13831                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13832                    inner_depth.increment()?;
13833                }
13834                let val_ref = self.partition_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
13835                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
13836                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13837                {
13838                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13839                }
13840                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13841                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13842                }
13843            }
13844
13845            next_offset += envelope_size;
13846            _next_ordinal_to_read += 1;
13847            if next_offset >= end_offset {
13848                return Ok(());
13849            }
13850
13851            // Decode unknown envelopes for gaps in ordinals.
13852            while _next_ordinal_to_read < 5 {
13853                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13854                _next_ordinal_to_read += 1;
13855                next_offset += envelope_size;
13856            }
13857
13858            let next_out_of_line = decoder.next_out_of_line();
13859            let handles_before = decoder.remaining_handles();
13860            if let Some((inlined, num_bytes, num_handles)) =
13861                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13862            {
13863                let member_inline_size =
13864                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
13865                        decoder.context,
13866                    );
13867                if inlined != (member_inline_size <= 4) {
13868                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13869                }
13870                let inner_offset;
13871                let mut inner_depth = depth.clone();
13872                if inlined {
13873                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13874                    inner_offset = next_offset;
13875                } else {
13876                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13877                    inner_depth.increment()?;
13878                }
13879                let val_ref = self
13880                    .stack_version
13881                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
13882                fidl::decode!(
13883                    fidl::encoding::BoundedString<256>,
13884                    D,
13885                    val_ref,
13886                    decoder,
13887                    inner_offset,
13888                    inner_depth
13889                )?;
13890                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13891                {
13892                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13893                }
13894                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13895                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13896                }
13897            }
13898
13899            next_offset += envelope_size;
13900            _next_ordinal_to_read += 1;
13901            if next_offset >= end_offset {
13902                return Ok(());
13903            }
13904
13905            // Decode unknown envelopes for gaps in ordinals.
13906            while _next_ordinal_to_read < 6 {
13907                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13908                _next_ordinal_to_read += 1;
13909                next_offset += envelope_size;
13910            }
13911
13912            let next_out_of_line = decoder.next_out_of_line();
13913            let handles_before = decoder.remaining_handles();
13914            if let Some((inlined, num_bytes, num_handles)) =
13915                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13916            {
13917                let member_inline_size =
13918                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
13919                        decoder.context,
13920                    );
13921                if inlined != (member_inline_size <= 4) {
13922                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13923                }
13924                let inner_offset;
13925                let mut inner_depth = depth.clone();
13926                if inlined {
13927                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13928                    inner_offset = next_offset;
13929                } else {
13930                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13931                    inner_depth.increment()?;
13932                }
13933                let val_ref = self
13934                    .rcp_version
13935                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
13936                fidl::decode!(
13937                    fidl::encoding::BoundedString<256>,
13938                    D,
13939                    val_ref,
13940                    decoder,
13941                    inner_offset,
13942                    inner_depth
13943                )?;
13944                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13945                {
13946                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13947                }
13948                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13949                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13950                }
13951            }
13952
13953            next_offset += envelope_size;
13954            _next_ordinal_to_read += 1;
13955            if next_offset >= end_offset {
13956                return Ok(());
13957            }
13958
13959            // Decode unknown envelopes for gaps in ordinals.
13960            while _next_ordinal_to_read < 7 {
13961                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13962                _next_ordinal_to_read += 1;
13963                next_offset += envelope_size;
13964            }
13965
13966            let next_out_of_line = decoder.next_out_of_line();
13967            let handles_before = decoder.remaining_handles();
13968            if let Some((inlined, num_bytes, num_handles)) =
13969                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13970            {
13971                let member_inline_size =
13972                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13973                if inlined != (member_inline_size <= 4) {
13974                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13975                }
13976                let inner_offset;
13977                let mut inner_depth = depth.clone();
13978                if inlined {
13979                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13980                    inner_offset = next_offset;
13981                } else {
13982                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13983                    inner_depth.increment()?;
13984                }
13985                let val_ref = self.thread_link_mode.get_or_insert_with(|| fidl::new_empty!(u8, D));
13986                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
13987                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13988                {
13989                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13990                }
13991                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13992                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13993                }
13994            }
13995
13996            next_offset += envelope_size;
13997            _next_ordinal_to_read += 1;
13998            if next_offset >= end_offset {
13999                return Ok(());
14000            }
14001
14002            // Decode unknown envelopes for gaps in ordinals.
14003            while _next_ordinal_to_read < 8 {
14004                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14005                _next_ordinal_to_read += 1;
14006                next_offset += envelope_size;
14007            }
14008
14009            let next_out_of_line = decoder.next_out_of_line();
14010            let handles_before = decoder.remaining_handles();
14011            if let Some((inlined, num_bytes, num_handles)) =
14012                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14013            {
14014                let member_inline_size =
14015                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14016                if inlined != (member_inline_size <= 4) {
14017                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14018                }
14019                let inner_offset;
14020                let mut inner_depth = depth.clone();
14021                if inlined {
14022                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14023                    inner_offset = next_offset;
14024                } else {
14025                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14026                    inner_depth.increment()?;
14027                }
14028                let val_ref = self.thread_router_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
14029                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
14030                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14031                {
14032                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14033                }
14034                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14035                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14036                }
14037            }
14038
14039            next_offset += envelope_size;
14040            _next_ordinal_to_read += 1;
14041            if next_offset >= end_offset {
14042                return Ok(());
14043            }
14044
14045            // Decode unknown envelopes for gaps in ordinals.
14046            while _next_ordinal_to_read < 9 {
14047                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14048                _next_ordinal_to_read += 1;
14049                next_offset += envelope_size;
14050            }
14051
14052            let next_out_of_line = decoder.next_out_of_line();
14053            let handles_before = decoder.remaining_handles();
14054            if let Some((inlined, num_bytes, num_handles)) =
14055                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14056            {
14057                let member_inline_size =
14058                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14059                if inlined != (member_inline_size <= 4) {
14060                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14061                }
14062                let inner_offset;
14063                let mut inner_depth = depth.clone();
14064                if inlined {
14065                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14066                    inner_offset = next_offset;
14067                } else {
14068                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14069                    inner_depth.increment()?;
14070                }
14071                let val_ref = self.thread_rloc.get_or_insert_with(|| fidl::new_empty!(u16, D));
14072                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
14073                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14074                {
14075                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14076                }
14077                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14078                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14079                }
14080            }
14081
14082            next_offset += envelope_size;
14083            _next_ordinal_to_read += 1;
14084            if next_offset >= end_offset {
14085                return Ok(());
14086            }
14087
14088            // Decode unknown envelopes for gaps in ordinals.
14089            while _next_ordinal_to_read < 10 {
14090                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14091                _next_ordinal_to_read += 1;
14092                next_offset += envelope_size;
14093            }
14094
14095            let next_out_of_line = decoder.next_out_of_line();
14096            let handles_before = decoder.remaining_handles();
14097            if let Some((inlined, num_bytes, num_handles)) =
14098                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14099            {
14100                let member_inline_size =
14101                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14102                if inlined != (member_inline_size <= 4) {
14103                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14104                }
14105                let inner_offset;
14106                let mut inner_depth = depth.clone();
14107                if inlined {
14108                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14109                    inner_offset = next_offset;
14110                } else {
14111                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14112                    inner_depth.increment()?;
14113                }
14114                let val_ref =
14115                    self.thread_network_data_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
14116                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
14117                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14118                {
14119                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14120                }
14121                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14122                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14123                }
14124            }
14125
14126            next_offset += envelope_size;
14127            _next_ordinal_to_read += 1;
14128            if next_offset >= end_offset {
14129                return Ok(());
14130            }
14131
14132            // Decode unknown envelopes for gaps in ordinals.
14133            while _next_ordinal_to_read < 11 {
14134                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14135                _next_ordinal_to_read += 1;
14136                next_offset += envelope_size;
14137            }
14138
14139            let next_out_of_line = decoder.next_out_of_line();
14140            let handles_before = decoder.remaining_handles();
14141            if let Some((inlined, num_bytes, num_handles)) =
14142                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14143            {
14144                let member_inline_size =
14145                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14146                if inlined != (member_inline_size <= 4) {
14147                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14148                }
14149                let inner_offset;
14150                let mut inner_depth = depth.clone();
14151                if inlined {
14152                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14153                    inner_offset = next_offset;
14154                } else {
14155                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14156                    inner_depth.increment()?;
14157                }
14158                let val_ref = self
14159                    .thread_stable_network_data_version
14160                    .get_or_insert_with(|| fidl::new_empty!(u8, D));
14161                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
14162                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14163                {
14164                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14165                }
14166                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14167                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14168                }
14169            }
14170
14171            next_offset += envelope_size;
14172            _next_ordinal_to_read += 1;
14173            if next_offset >= end_offset {
14174                return Ok(());
14175            }
14176
14177            // Decode unknown envelopes for gaps in ordinals.
14178            while _next_ordinal_to_read < 12 {
14179                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14180                _next_ordinal_to_read += 1;
14181                next_offset += envelope_size;
14182            }
14183
14184            let next_out_of_line = decoder.next_out_of_line();
14185            let handles_before = decoder.remaining_handles();
14186            if let Some((inlined, num_bytes, num_handles)) =
14187                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14188            {
14189                let member_inline_size =
14190                    <fidl::encoding::Vector<u8, 255> as fidl::encoding::TypeMarker>::inline_size(
14191                        decoder.context,
14192                    );
14193                if inlined != (member_inline_size <= 4) {
14194                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14195                }
14196                let inner_offset;
14197                let mut inner_depth = depth.clone();
14198                if inlined {
14199                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14200                    inner_offset = next_offset;
14201                } else {
14202                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14203                    inner_depth.increment()?;
14204                }
14205                let val_ref = self
14206                    .thread_network_data
14207                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 255>, D));
14208                fidl::decode!(fidl::encoding::Vector<u8, 255>, D, val_ref, decoder, inner_offset, inner_depth)?;
14209                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14210                {
14211                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14212                }
14213                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14214                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14215                }
14216            }
14217
14218            next_offset += envelope_size;
14219            _next_ordinal_to_read += 1;
14220            if next_offset >= end_offset {
14221                return Ok(());
14222            }
14223
14224            // Decode unknown envelopes for gaps in ordinals.
14225            while _next_ordinal_to_read < 13 {
14226                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14227                _next_ordinal_to_read += 1;
14228                next_offset += envelope_size;
14229            }
14230
14231            let next_out_of_line = decoder.next_out_of_line();
14232            let handles_before = decoder.remaining_handles();
14233            if let Some((inlined, num_bytes, num_handles)) =
14234                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14235            {
14236                let member_inline_size =
14237                    <fidl::encoding::Vector<u8, 255> as fidl::encoding::TypeMarker>::inline_size(
14238                        decoder.context,
14239                    );
14240                if inlined != (member_inline_size <= 4) {
14241                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14242                }
14243                let inner_offset;
14244                let mut inner_depth = depth.clone();
14245                if inlined {
14246                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14247                    inner_offset = next_offset;
14248                } else {
14249                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14250                    inner_depth.increment()?;
14251                }
14252                let val_ref = self
14253                    .thread_stable_network_data
14254                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 255>, D));
14255                fidl::decode!(fidl::encoding::Vector<u8, 255>, D, val_ref, decoder, inner_offset, inner_depth)?;
14256                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14257                {
14258                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14259                }
14260                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14261                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14262                }
14263            }
14264
14265            next_offset += envelope_size;
14266            _next_ordinal_to_read += 1;
14267            if next_offset >= end_offset {
14268                return Ok(());
14269            }
14270
14271            // Decode unknown envelopes for gaps in ordinals.
14272            while _next_ordinal_to_read < 14 {
14273                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14274                _next_ordinal_to_read += 1;
14275                next_offset += envelope_size;
14276            }
14277
14278            let next_out_of_line = decoder.next_out_of_line();
14279            let handles_before = decoder.remaining_handles();
14280            if let Some((inlined, num_bytes, num_handles)) =
14281                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14282            {
14283                let member_inline_size =
14284                    <BorderRoutingCounters as fidl::encoding::TypeMarker>::inline_size(
14285                        decoder.context,
14286                    );
14287                if inlined != (member_inline_size <= 4) {
14288                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14289                }
14290                let inner_offset;
14291                let mut inner_depth = depth.clone();
14292                if inlined {
14293                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14294                    inner_offset = next_offset;
14295                } else {
14296                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14297                    inner_depth.increment()?;
14298                }
14299                let val_ref = self
14300                    .thread_border_routing_counters
14301                    .get_or_insert_with(|| fidl::new_empty!(BorderRoutingCounters, D));
14302                fidl::decode!(
14303                    BorderRoutingCounters,
14304                    D,
14305                    val_ref,
14306                    decoder,
14307                    inner_offset,
14308                    inner_depth
14309                )?;
14310                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14311                {
14312                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14313                }
14314                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14315                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14316                }
14317            }
14318
14319            next_offset += envelope_size;
14320            _next_ordinal_to_read += 1;
14321            if next_offset >= end_offset {
14322                return Ok(());
14323            }
14324
14325            // Decode unknown envelopes for gaps in ordinals.
14326            while _next_ordinal_to_read < 15 {
14327                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14328                _next_ordinal_to_read += 1;
14329                next_offset += envelope_size;
14330            }
14331
14332            let next_out_of_line = decoder.next_out_of_line();
14333            let handles_before = decoder.remaining_handles();
14334            if let Some((inlined, num_bytes, num_handles)) =
14335                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14336            {
14337                let member_inline_size =
14338                    <SrpServerInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14339                if inlined != (member_inline_size <= 4) {
14340                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14341                }
14342                let inner_offset;
14343                let mut inner_depth = depth.clone();
14344                if inlined {
14345                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14346                    inner_offset = next_offset;
14347                } else {
14348                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14349                    inner_depth.increment()?;
14350                }
14351                let val_ref =
14352                    self.srp_server_info.get_or_insert_with(|| fidl::new_empty!(SrpServerInfo, D));
14353                fidl::decode!(SrpServerInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
14354                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14355                {
14356                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14357                }
14358                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14359                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14360                }
14361            }
14362
14363            next_offset += envelope_size;
14364            _next_ordinal_to_read += 1;
14365            if next_offset >= end_offset {
14366                return Ok(());
14367            }
14368
14369            // Decode unknown envelopes for gaps in ordinals.
14370            while _next_ordinal_to_read < 16 {
14371                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14372                _next_ordinal_to_read += 1;
14373                next_offset += envelope_size;
14374            }
14375
14376            let next_out_of_line = decoder.next_out_of_line();
14377            let handles_before = decoder.remaining_handles();
14378            if let Some((inlined, num_bytes, num_handles)) =
14379                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14380            {
14381                let member_inline_size =
14382                    <DnssdCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14383                if inlined != (member_inline_size <= 4) {
14384                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14385                }
14386                let inner_offset;
14387                let mut inner_depth = depth.clone();
14388                if inlined {
14389                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14390                    inner_offset = next_offset;
14391                } else {
14392                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14393                    inner_depth.increment()?;
14394                }
14395                let val_ref =
14396                    self.dnssd_counters.get_or_insert_with(|| fidl::new_empty!(DnssdCounters, D));
14397                fidl::decode!(DnssdCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
14398                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14399                {
14400                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14401                }
14402                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14403                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14404                }
14405            }
14406
14407            next_offset += envelope_size;
14408            _next_ordinal_to_read += 1;
14409            if next_offset >= end_offset {
14410                return Ok(());
14411            }
14412
14413            // Decode unknown envelopes for gaps in ordinals.
14414            while _next_ordinal_to_read < 17 {
14415                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14416                _next_ordinal_to_read += 1;
14417                next_offset += envelope_size;
14418            }
14419
14420            let next_out_of_line = decoder.next_out_of_line();
14421            let handles_before = decoder.remaining_handles();
14422            if let Some((inlined, num_bytes, num_handles)) =
14423                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14424            {
14425                let member_inline_size =
14426                    <LeaderData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14427                if inlined != (member_inline_size <= 4) {
14428                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14429                }
14430                let inner_offset;
14431                let mut inner_depth = depth.clone();
14432                if inlined {
14433                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14434                    inner_offset = next_offset;
14435                } else {
14436                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14437                    inner_depth.increment()?;
14438                }
14439                let val_ref =
14440                    self.leader_data.get_or_insert_with(|| fidl::new_empty!(LeaderData, D));
14441                fidl::decode!(LeaderData, D, val_ref, decoder, inner_offset, inner_depth)?;
14442                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14443                {
14444                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14445                }
14446                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14447                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14448                }
14449            }
14450
14451            next_offset += envelope_size;
14452            _next_ordinal_to_read += 1;
14453            if next_offset >= end_offset {
14454                return Ok(());
14455            }
14456
14457            // Decode unknown envelopes for gaps in ordinals.
14458            while _next_ordinal_to_read < 18 {
14459                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14460                _next_ordinal_to_read += 1;
14461                next_offset += envelope_size;
14462            }
14463
14464            let next_out_of_line = decoder.next_out_of_line();
14465            let handles_before = decoder.remaining_handles();
14466            if let Some((inlined, num_bytes, num_handles)) =
14467                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14468            {
14469                let member_inline_size =
14470                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14471                if inlined != (member_inline_size <= 4) {
14472                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14473                }
14474                let inner_offset;
14475                let mut inner_depth = depth.clone();
14476                if inlined {
14477                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14478                    inner_offset = next_offset;
14479                } else {
14480                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14481                    inner_depth.increment()?;
14482                }
14483                let val_ref = self.uptime.get_or_insert_with(|| fidl::new_empty!(i64, D));
14484                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
14485                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14486                {
14487                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14488                }
14489                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14490                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14491                }
14492            }
14493
14494            next_offset += envelope_size;
14495            _next_ordinal_to_read += 1;
14496            if next_offset >= end_offset {
14497                return Ok(());
14498            }
14499
14500            // Decode unknown envelopes for gaps in ordinals.
14501            while _next_ordinal_to_read < 19 {
14502                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14503                _next_ordinal_to_read += 1;
14504                next_offset += envelope_size;
14505            }
14506
14507            let next_out_of_line = decoder.next_out_of_line();
14508            let handles_before = decoder.remaining_handles();
14509            if let Some((inlined, num_bytes, num_handles)) =
14510                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14511            {
14512                let member_inline_size =
14513                    <Nat64Info as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14514                if inlined != (member_inline_size <= 4) {
14515                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14516                }
14517                let inner_offset;
14518                let mut inner_depth = depth.clone();
14519                if inlined {
14520                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14521                    inner_offset = next_offset;
14522                } else {
14523                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14524                    inner_depth.increment()?;
14525                }
14526                let val_ref = self.nat64_info.get_or_insert_with(|| fidl::new_empty!(Nat64Info, D));
14527                fidl::decode!(Nat64Info, D, val_ref, decoder, inner_offset, inner_depth)?;
14528                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14529                {
14530                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14531                }
14532                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14533                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14534                }
14535            }
14536
14537            next_offset += envelope_size;
14538            _next_ordinal_to_read += 1;
14539            if next_offset >= end_offset {
14540                return Ok(());
14541            }
14542
14543            // Decode unknown envelopes for gaps in ordinals.
14544            while _next_ordinal_to_read < 20 {
14545                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14546                _next_ordinal_to_read += 1;
14547                next_offset += envelope_size;
14548            }
14549
14550            let next_out_of_line = decoder.next_out_of_line();
14551            let handles_before = decoder.remaining_handles();
14552            if let Some((inlined, num_bytes, num_handles)) =
14553                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14554            {
14555                let member_inline_size =
14556                    <TrelCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14557                if inlined != (member_inline_size <= 4) {
14558                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14559                }
14560                let inner_offset;
14561                let mut inner_depth = depth.clone();
14562                if inlined {
14563                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14564                    inner_offset = next_offset;
14565                } else {
14566                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14567                    inner_depth.increment()?;
14568                }
14569                let val_ref =
14570                    self.trel_counters.get_or_insert_with(|| fidl::new_empty!(TrelCounters, D));
14571                fidl::decode!(TrelCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
14572                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14573                {
14574                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14575                }
14576                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14577                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14578                }
14579            }
14580
14581            next_offset += envelope_size;
14582            _next_ordinal_to_read += 1;
14583            if next_offset >= end_offset {
14584                return Ok(());
14585            }
14586
14587            // Decode unknown envelopes for gaps in ordinals.
14588            while _next_ordinal_to_read < 21 {
14589                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14590                _next_ordinal_to_read += 1;
14591                next_offset += envelope_size;
14592            }
14593
14594            let next_out_of_line = decoder.next_out_of_line();
14595            let handles_before = decoder.remaining_handles();
14596            if let Some((inlined, num_bytes, num_handles)) =
14597                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14598            {
14599                let member_inline_size =
14600                    <TrelPeersInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14601                if inlined != (member_inline_size <= 4) {
14602                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14603                }
14604                let inner_offset;
14605                let mut inner_depth = depth.clone();
14606                if inlined {
14607                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14608                    inner_offset = next_offset;
14609                } else {
14610                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14611                    inner_depth.increment()?;
14612                }
14613                let val_ref =
14614                    self.trel_peers_info.get_or_insert_with(|| fidl::new_empty!(TrelPeersInfo, D));
14615                fidl::decode!(TrelPeersInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
14616                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14617                {
14618                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14619                }
14620                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14621                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14622                }
14623            }
14624
14625            next_offset += envelope_size;
14626            _next_ordinal_to_read += 1;
14627            if next_offset >= end_offset {
14628                return Ok(());
14629            }
14630
14631            // Decode unknown envelopes for gaps in ordinals.
14632            while _next_ordinal_to_read < 22 {
14633                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14634                _next_ordinal_to_read += 1;
14635                next_offset += envelope_size;
14636            }
14637
14638            let next_out_of_line = decoder.next_out_of_line();
14639            let handles_before = decoder.remaining_handles();
14640            if let Some((inlined, num_bytes, num_handles)) =
14641                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14642            {
14643                let member_inline_size =
14644                    <UpstreamDnsInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14645                if inlined != (member_inline_size <= 4) {
14646                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14647                }
14648                let inner_offset;
14649                let mut inner_depth = depth.clone();
14650                if inlined {
14651                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14652                    inner_offset = next_offset;
14653                } else {
14654                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14655                    inner_depth.increment()?;
14656                }
14657                let val_ref = self
14658                    .upstream_dns_info
14659                    .get_or_insert_with(|| fidl::new_empty!(UpstreamDnsInfo, D));
14660                fidl::decode!(UpstreamDnsInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
14661                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14662                {
14663                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14664                }
14665                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14666                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14667                }
14668            }
14669
14670            next_offset += envelope_size;
14671            _next_ordinal_to_read += 1;
14672            if next_offset >= end_offset {
14673                return Ok(());
14674            }
14675
14676            // Decode unknown envelopes for gaps in ordinals.
14677            while _next_ordinal_to_read < 23 {
14678                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14679                _next_ordinal_to_read += 1;
14680                next_offset += envelope_size;
14681            }
14682
14683            let next_out_of_line = decoder.next_out_of_line();
14684            let handles_before = decoder.remaining_handles();
14685            if let Some((inlined, num_bytes, num_handles)) =
14686                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14687            {
14688                let member_inline_size =
14689                    <Dhcp6PdInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14690                if inlined != (member_inline_size <= 4) {
14691                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14692                }
14693                let inner_offset;
14694                let mut inner_depth = depth.clone();
14695                if inlined {
14696                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14697                    inner_offset = next_offset;
14698                } else {
14699                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14700                    inner_depth.increment()?;
14701                }
14702                let val_ref =
14703                    self.dhcp6pd_info.get_or_insert_with(|| fidl::new_empty!(Dhcp6PdInfo, D));
14704                fidl::decode!(Dhcp6PdInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
14705                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14706                {
14707                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14708                }
14709                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14710                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14711                }
14712            }
14713
14714            next_offset += envelope_size;
14715            _next_ordinal_to_read += 1;
14716            if next_offset >= end_offset {
14717                return Ok(());
14718            }
14719
14720            // Decode unknown envelopes for gaps in ordinals.
14721            while _next_ordinal_to_read < 24 {
14722                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14723                _next_ordinal_to_read += 1;
14724                next_offset += envelope_size;
14725            }
14726
14727            let next_out_of_line = decoder.next_out_of_line();
14728            let handles_before = decoder.remaining_handles();
14729            if let Some((inlined, num_bytes, num_handles)) =
14730                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14731            {
14732                let member_inline_size = <fidl::encoding::Vector<LinkMetricsEntry, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14733                if inlined != (member_inline_size <= 4) {
14734                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14735                }
14736                let inner_offset;
14737                let mut inner_depth = depth.clone();
14738                if inlined {
14739                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14740                    inner_offset = next_offset;
14741                } else {
14742                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14743                    inner_depth.increment()?;
14744                }
14745                let val_ref = self.link_metrics_entries.get_or_insert_with(
14746                    || fidl::new_empty!(fidl::encoding::Vector<LinkMetricsEntry, 64>, D),
14747                );
14748                fidl::decode!(fidl::encoding::Vector<LinkMetricsEntry, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
14749                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14750                {
14751                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14752                }
14753                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14754                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14755                }
14756            }
14757
14758            next_offset += envelope_size;
14759
14760            // Decode the remaining unknown envelopes.
14761            while next_offset < end_offset {
14762                _next_ordinal_to_read += 1;
14763                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14764                next_offset += envelope_size;
14765            }
14766
14767            Ok(())
14768        }
14769    }
14770
14771    impl TrelCounters {
14772        #[inline(always)]
14773        fn max_ordinal_present(&self) -> u64 {
14774            if let Some(_) = self.tx_packets {
14775                return 5;
14776            }
14777            if let Some(_) = self.tx_failure {
14778                return 4;
14779            }
14780            if let Some(_) = self.tx_bytes {
14781                return 3;
14782            }
14783            if let Some(_) = self.rx_packets {
14784                return 2;
14785            }
14786            if let Some(_) = self.rx_bytes {
14787                return 1;
14788            }
14789            0
14790        }
14791    }
14792
14793    impl fidl::encoding::ValueTypeMarker for TrelCounters {
14794        type Borrowed<'a> = &'a Self;
14795        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14796            value
14797        }
14798    }
14799
14800    unsafe impl fidl::encoding::TypeMarker for TrelCounters {
14801        type Owned = Self;
14802
14803        #[inline(always)]
14804        fn inline_align(_context: fidl::encoding::Context) -> usize {
14805            8
14806        }
14807
14808        #[inline(always)]
14809        fn inline_size(_context: fidl::encoding::Context) -> usize {
14810            16
14811        }
14812    }
14813
14814    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TrelCounters, D>
14815        for &TrelCounters
14816    {
14817        unsafe fn encode(
14818            self,
14819            encoder: &mut fidl::encoding::Encoder<'_, D>,
14820            offset: usize,
14821            mut depth: fidl::encoding::Depth,
14822        ) -> fidl::Result<()> {
14823            encoder.debug_check_bounds::<TrelCounters>(offset);
14824            // Vector header
14825            let max_ordinal: u64 = self.max_ordinal_present();
14826            encoder.write_num(max_ordinal, offset);
14827            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14828            // Calling encoder.out_of_line_offset(0) is not allowed.
14829            if max_ordinal == 0 {
14830                return Ok(());
14831            }
14832            depth.increment()?;
14833            let envelope_size = 8;
14834            let bytes_len = max_ordinal as usize * envelope_size;
14835            #[allow(unused_variables)]
14836            let offset = encoder.out_of_line_offset(bytes_len);
14837            let mut _prev_end_offset: usize = 0;
14838            if 1 > max_ordinal {
14839                return Ok(());
14840            }
14841
14842            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14843            // are envelope_size bytes.
14844            let cur_offset: usize = (1 - 1) * envelope_size;
14845
14846            // Zero reserved fields.
14847            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14848
14849            // Safety:
14850            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14851            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14852            //   envelope_size bytes, there is always sufficient room.
14853            fidl::encoding::encode_in_envelope_optional::<u64, D>(
14854                self.rx_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14855                encoder,
14856                offset + cur_offset,
14857                depth,
14858            )?;
14859
14860            _prev_end_offset = cur_offset + envelope_size;
14861            if 2 > max_ordinal {
14862                return Ok(());
14863            }
14864
14865            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14866            // are envelope_size bytes.
14867            let cur_offset: usize = (2 - 1) * envelope_size;
14868
14869            // Zero reserved fields.
14870            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14871
14872            // Safety:
14873            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14874            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14875            //   envelope_size bytes, there is always sufficient room.
14876            fidl::encoding::encode_in_envelope_optional::<u64, D>(
14877                self.rx_packets.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14878                encoder,
14879                offset + cur_offset,
14880                depth,
14881            )?;
14882
14883            _prev_end_offset = cur_offset + envelope_size;
14884            if 3 > max_ordinal {
14885                return Ok(());
14886            }
14887
14888            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14889            // are envelope_size bytes.
14890            let cur_offset: usize = (3 - 1) * envelope_size;
14891
14892            // Zero reserved fields.
14893            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14894
14895            // Safety:
14896            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14897            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14898            //   envelope_size bytes, there is always sufficient room.
14899            fidl::encoding::encode_in_envelope_optional::<u64, D>(
14900                self.tx_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14901                encoder,
14902                offset + cur_offset,
14903                depth,
14904            )?;
14905
14906            _prev_end_offset = cur_offset + envelope_size;
14907            if 4 > max_ordinal {
14908                return Ok(());
14909            }
14910
14911            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14912            // are envelope_size bytes.
14913            let cur_offset: usize = (4 - 1) * envelope_size;
14914
14915            // Zero reserved fields.
14916            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14917
14918            // Safety:
14919            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14920            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14921            //   envelope_size bytes, there is always sufficient room.
14922            fidl::encoding::encode_in_envelope_optional::<u64, D>(
14923                self.tx_failure.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14924                encoder,
14925                offset + cur_offset,
14926                depth,
14927            )?;
14928
14929            _prev_end_offset = cur_offset + envelope_size;
14930            if 5 > max_ordinal {
14931                return Ok(());
14932            }
14933
14934            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14935            // are envelope_size bytes.
14936            let cur_offset: usize = (5 - 1) * envelope_size;
14937
14938            // Zero reserved fields.
14939            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14940
14941            // Safety:
14942            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14943            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14944            //   envelope_size bytes, there is always sufficient room.
14945            fidl::encoding::encode_in_envelope_optional::<u64, D>(
14946                self.tx_packets.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14947                encoder,
14948                offset + cur_offset,
14949                depth,
14950            )?;
14951
14952            _prev_end_offset = cur_offset + envelope_size;
14953
14954            Ok(())
14955        }
14956    }
14957
14958    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TrelCounters {
14959        #[inline(always)]
14960        fn new_empty() -> Self {
14961            Self::default()
14962        }
14963
14964        unsafe fn decode(
14965            &mut self,
14966            decoder: &mut fidl::encoding::Decoder<'_, D>,
14967            offset: usize,
14968            mut depth: fidl::encoding::Depth,
14969        ) -> fidl::Result<()> {
14970            decoder.debug_check_bounds::<Self>(offset);
14971            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
14972                None => return Err(fidl::Error::NotNullable),
14973                Some(len) => len,
14974            };
14975            // Calling decoder.out_of_line_offset(0) is not allowed.
14976            if len == 0 {
14977                return Ok(());
14978            };
14979            depth.increment()?;
14980            let envelope_size = 8;
14981            let bytes_len = len * envelope_size;
14982            let offset = decoder.out_of_line_offset(bytes_len)?;
14983            // Decode the envelope for each type.
14984            let mut _next_ordinal_to_read = 0;
14985            let mut next_offset = offset;
14986            let end_offset = offset + bytes_len;
14987            _next_ordinal_to_read += 1;
14988            if next_offset >= end_offset {
14989                return Ok(());
14990            }
14991
14992            // Decode unknown envelopes for gaps in ordinals.
14993            while _next_ordinal_to_read < 1 {
14994                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14995                _next_ordinal_to_read += 1;
14996                next_offset += envelope_size;
14997            }
14998
14999            let next_out_of_line = decoder.next_out_of_line();
15000            let handles_before = decoder.remaining_handles();
15001            if let Some((inlined, num_bytes, num_handles)) =
15002                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15003            {
15004                let member_inline_size =
15005                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15006                if inlined != (member_inline_size <= 4) {
15007                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15008                }
15009                let inner_offset;
15010                let mut inner_depth = depth.clone();
15011                if inlined {
15012                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15013                    inner_offset = next_offset;
15014                } else {
15015                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15016                    inner_depth.increment()?;
15017                }
15018                let val_ref = self.rx_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
15019                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15020                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15021                {
15022                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15023                }
15024                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15025                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15026                }
15027            }
15028
15029            next_offset += envelope_size;
15030            _next_ordinal_to_read += 1;
15031            if next_offset >= end_offset {
15032                return Ok(());
15033            }
15034
15035            // Decode unknown envelopes for gaps in ordinals.
15036            while _next_ordinal_to_read < 2 {
15037                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15038                _next_ordinal_to_read += 1;
15039                next_offset += envelope_size;
15040            }
15041
15042            let next_out_of_line = decoder.next_out_of_line();
15043            let handles_before = decoder.remaining_handles();
15044            if let Some((inlined, num_bytes, num_handles)) =
15045                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15046            {
15047                let member_inline_size =
15048                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15049                if inlined != (member_inline_size <= 4) {
15050                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15051                }
15052                let inner_offset;
15053                let mut inner_depth = depth.clone();
15054                if inlined {
15055                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15056                    inner_offset = next_offset;
15057                } else {
15058                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15059                    inner_depth.increment()?;
15060                }
15061                let val_ref = self.rx_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
15062                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15063                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15064                {
15065                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15066                }
15067                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15068                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15069                }
15070            }
15071
15072            next_offset += envelope_size;
15073            _next_ordinal_to_read += 1;
15074            if next_offset >= end_offset {
15075                return Ok(());
15076            }
15077
15078            // Decode unknown envelopes for gaps in ordinals.
15079            while _next_ordinal_to_read < 3 {
15080                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15081                _next_ordinal_to_read += 1;
15082                next_offset += envelope_size;
15083            }
15084
15085            let next_out_of_line = decoder.next_out_of_line();
15086            let handles_before = decoder.remaining_handles();
15087            if let Some((inlined, num_bytes, num_handles)) =
15088                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15089            {
15090                let member_inline_size =
15091                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15092                if inlined != (member_inline_size <= 4) {
15093                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15094                }
15095                let inner_offset;
15096                let mut inner_depth = depth.clone();
15097                if inlined {
15098                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15099                    inner_offset = next_offset;
15100                } else {
15101                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15102                    inner_depth.increment()?;
15103                }
15104                let val_ref = self.tx_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
15105                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15106                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15107                {
15108                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15109                }
15110                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15111                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15112                }
15113            }
15114
15115            next_offset += envelope_size;
15116            _next_ordinal_to_read += 1;
15117            if next_offset >= end_offset {
15118                return Ok(());
15119            }
15120
15121            // Decode unknown envelopes for gaps in ordinals.
15122            while _next_ordinal_to_read < 4 {
15123                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15124                _next_ordinal_to_read += 1;
15125                next_offset += envelope_size;
15126            }
15127
15128            let next_out_of_line = decoder.next_out_of_line();
15129            let handles_before = decoder.remaining_handles();
15130            if let Some((inlined, num_bytes, num_handles)) =
15131                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15132            {
15133                let member_inline_size =
15134                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15135                if inlined != (member_inline_size <= 4) {
15136                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15137                }
15138                let inner_offset;
15139                let mut inner_depth = depth.clone();
15140                if inlined {
15141                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15142                    inner_offset = next_offset;
15143                } else {
15144                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15145                    inner_depth.increment()?;
15146                }
15147                let val_ref = self.tx_failure.get_or_insert_with(|| fidl::new_empty!(u64, D));
15148                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15149                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15150                {
15151                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15152                }
15153                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15154                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15155                }
15156            }
15157
15158            next_offset += envelope_size;
15159            _next_ordinal_to_read += 1;
15160            if next_offset >= end_offset {
15161                return Ok(());
15162            }
15163
15164            // Decode unknown envelopes for gaps in ordinals.
15165            while _next_ordinal_to_read < 5 {
15166                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15167                _next_ordinal_to_read += 1;
15168                next_offset += envelope_size;
15169            }
15170
15171            let next_out_of_line = decoder.next_out_of_line();
15172            let handles_before = decoder.remaining_handles();
15173            if let Some((inlined, num_bytes, num_handles)) =
15174                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15175            {
15176                let member_inline_size =
15177                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15178                if inlined != (member_inline_size <= 4) {
15179                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15180                }
15181                let inner_offset;
15182                let mut inner_depth = depth.clone();
15183                if inlined {
15184                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15185                    inner_offset = next_offset;
15186                } else {
15187                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15188                    inner_depth.increment()?;
15189                }
15190                let val_ref = self.tx_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
15191                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15192                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15193                {
15194                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15195                }
15196                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15197                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15198                }
15199            }
15200
15201            next_offset += envelope_size;
15202
15203            // Decode the remaining unknown envelopes.
15204            while next_offset < end_offset {
15205                _next_ordinal_to_read += 1;
15206                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15207                next_offset += envelope_size;
15208            }
15209
15210            Ok(())
15211        }
15212    }
15213
15214    impl TrelPeersInfo {
15215        #[inline(always)]
15216        fn max_ordinal_present(&self) -> u64 {
15217            if let Some(_) = self.num_trel_peers {
15218                return 1;
15219            }
15220            0
15221        }
15222    }
15223
15224    impl fidl::encoding::ValueTypeMarker for TrelPeersInfo {
15225        type Borrowed<'a> = &'a Self;
15226        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15227            value
15228        }
15229    }
15230
15231    unsafe impl fidl::encoding::TypeMarker for TrelPeersInfo {
15232        type Owned = Self;
15233
15234        #[inline(always)]
15235        fn inline_align(_context: fidl::encoding::Context) -> usize {
15236            8
15237        }
15238
15239        #[inline(always)]
15240        fn inline_size(_context: fidl::encoding::Context) -> usize {
15241            16
15242        }
15243    }
15244
15245    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TrelPeersInfo, D>
15246        for &TrelPeersInfo
15247    {
15248        unsafe fn encode(
15249            self,
15250            encoder: &mut fidl::encoding::Encoder<'_, D>,
15251            offset: usize,
15252            mut depth: fidl::encoding::Depth,
15253        ) -> fidl::Result<()> {
15254            encoder.debug_check_bounds::<TrelPeersInfo>(offset);
15255            // Vector header
15256            let max_ordinal: u64 = self.max_ordinal_present();
15257            encoder.write_num(max_ordinal, offset);
15258            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15259            // Calling encoder.out_of_line_offset(0) is not allowed.
15260            if max_ordinal == 0 {
15261                return Ok(());
15262            }
15263            depth.increment()?;
15264            let envelope_size = 8;
15265            let bytes_len = max_ordinal as usize * envelope_size;
15266            #[allow(unused_variables)]
15267            let offset = encoder.out_of_line_offset(bytes_len);
15268            let mut _prev_end_offset: usize = 0;
15269            if 1 > max_ordinal {
15270                return Ok(());
15271            }
15272
15273            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15274            // are envelope_size bytes.
15275            let cur_offset: usize = (1 - 1) * envelope_size;
15276
15277            // Zero reserved fields.
15278            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15279
15280            // Safety:
15281            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15282            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15283            //   envelope_size bytes, there is always sufficient room.
15284            fidl::encoding::encode_in_envelope_optional::<u16, D>(
15285                self.num_trel_peers.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
15286                encoder,
15287                offset + cur_offset,
15288                depth,
15289            )?;
15290
15291            _prev_end_offset = cur_offset + envelope_size;
15292
15293            Ok(())
15294        }
15295    }
15296
15297    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TrelPeersInfo {
15298        #[inline(always)]
15299        fn new_empty() -> Self {
15300            Self::default()
15301        }
15302
15303        unsafe fn decode(
15304            &mut self,
15305            decoder: &mut fidl::encoding::Decoder<'_, D>,
15306            offset: usize,
15307            mut depth: fidl::encoding::Depth,
15308        ) -> fidl::Result<()> {
15309            decoder.debug_check_bounds::<Self>(offset);
15310            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15311                None => return Err(fidl::Error::NotNullable),
15312                Some(len) => len,
15313            };
15314            // Calling decoder.out_of_line_offset(0) is not allowed.
15315            if len == 0 {
15316                return Ok(());
15317            };
15318            depth.increment()?;
15319            let envelope_size = 8;
15320            let bytes_len = len * envelope_size;
15321            let offset = decoder.out_of_line_offset(bytes_len)?;
15322            // Decode the envelope for each type.
15323            let mut _next_ordinal_to_read = 0;
15324            let mut next_offset = offset;
15325            let end_offset = offset + bytes_len;
15326            _next_ordinal_to_read += 1;
15327            if next_offset >= end_offset {
15328                return Ok(());
15329            }
15330
15331            // Decode unknown envelopes for gaps in ordinals.
15332            while _next_ordinal_to_read < 1 {
15333                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15334                _next_ordinal_to_read += 1;
15335                next_offset += envelope_size;
15336            }
15337
15338            let next_out_of_line = decoder.next_out_of_line();
15339            let handles_before = decoder.remaining_handles();
15340            if let Some((inlined, num_bytes, num_handles)) =
15341                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15342            {
15343                let member_inline_size =
15344                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15345                if inlined != (member_inline_size <= 4) {
15346                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15347                }
15348                let inner_offset;
15349                let mut inner_depth = depth.clone();
15350                if inlined {
15351                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15352                    inner_offset = next_offset;
15353                } else {
15354                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15355                    inner_depth.increment()?;
15356                }
15357                let val_ref = self.num_trel_peers.get_or_insert_with(|| fidl::new_empty!(u16, D));
15358                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
15359                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15360                {
15361                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15362                }
15363                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15364                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15365                }
15366            }
15367
15368            next_offset += envelope_size;
15369
15370            // Decode the remaining unknown envelopes.
15371            while next_offset < end_offset {
15372                _next_ordinal_to_read += 1;
15373                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15374                next_offset += envelope_size;
15375            }
15376
15377            Ok(())
15378        }
15379    }
15380
15381    impl UpstreamDnsCounters {
15382        #[inline(always)]
15383        fn max_ordinal_present(&self) -> u64 {
15384            if let Some(_) = self.failures {
15385                return 3;
15386            }
15387            if let Some(_) = self.responses {
15388                return 2;
15389            }
15390            if let Some(_) = self.queries {
15391                return 1;
15392            }
15393            0
15394        }
15395    }
15396
15397    impl fidl::encoding::ValueTypeMarker for UpstreamDnsCounters {
15398        type Borrowed<'a> = &'a Self;
15399        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15400            value
15401        }
15402    }
15403
15404    unsafe impl fidl::encoding::TypeMarker for UpstreamDnsCounters {
15405        type Owned = Self;
15406
15407        #[inline(always)]
15408        fn inline_align(_context: fidl::encoding::Context) -> usize {
15409            8
15410        }
15411
15412        #[inline(always)]
15413        fn inline_size(_context: fidl::encoding::Context) -> usize {
15414            16
15415        }
15416    }
15417
15418    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UpstreamDnsCounters, D>
15419        for &UpstreamDnsCounters
15420    {
15421        unsafe fn encode(
15422            self,
15423            encoder: &mut fidl::encoding::Encoder<'_, D>,
15424            offset: usize,
15425            mut depth: fidl::encoding::Depth,
15426        ) -> fidl::Result<()> {
15427            encoder.debug_check_bounds::<UpstreamDnsCounters>(offset);
15428            // Vector header
15429            let max_ordinal: u64 = self.max_ordinal_present();
15430            encoder.write_num(max_ordinal, offset);
15431            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15432            // Calling encoder.out_of_line_offset(0) is not allowed.
15433            if max_ordinal == 0 {
15434                return Ok(());
15435            }
15436            depth.increment()?;
15437            let envelope_size = 8;
15438            let bytes_len = max_ordinal as usize * envelope_size;
15439            #[allow(unused_variables)]
15440            let offset = encoder.out_of_line_offset(bytes_len);
15441            let mut _prev_end_offset: usize = 0;
15442            if 1 > max_ordinal {
15443                return Ok(());
15444            }
15445
15446            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15447            // are envelope_size bytes.
15448            let cur_offset: usize = (1 - 1) * envelope_size;
15449
15450            // Zero reserved fields.
15451            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15452
15453            // Safety:
15454            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15455            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15456            //   envelope_size bytes, there is always sufficient room.
15457            fidl::encoding::encode_in_envelope_optional::<u32, D>(
15458                self.queries.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
15459                encoder,
15460                offset + cur_offset,
15461                depth,
15462            )?;
15463
15464            _prev_end_offset = cur_offset + envelope_size;
15465            if 2 > max_ordinal {
15466                return Ok(());
15467            }
15468
15469            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15470            // are envelope_size bytes.
15471            let cur_offset: usize = (2 - 1) * envelope_size;
15472
15473            // Zero reserved fields.
15474            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15475
15476            // Safety:
15477            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15478            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15479            //   envelope_size bytes, there is always sufficient room.
15480            fidl::encoding::encode_in_envelope_optional::<u32, D>(
15481                self.responses.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
15482                encoder,
15483                offset + cur_offset,
15484                depth,
15485            )?;
15486
15487            _prev_end_offset = cur_offset + envelope_size;
15488            if 3 > max_ordinal {
15489                return Ok(());
15490            }
15491
15492            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15493            // are envelope_size bytes.
15494            let cur_offset: usize = (3 - 1) * envelope_size;
15495
15496            // Zero reserved fields.
15497            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15498
15499            // Safety:
15500            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15501            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15502            //   envelope_size bytes, there is always sufficient room.
15503            fidl::encoding::encode_in_envelope_optional::<u32, D>(
15504                self.failures.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
15505                encoder,
15506                offset + cur_offset,
15507                depth,
15508            )?;
15509
15510            _prev_end_offset = cur_offset + envelope_size;
15511
15512            Ok(())
15513        }
15514    }
15515
15516    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UpstreamDnsCounters {
15517        #[inline(always)]
15518        fn new_empty() -> Self {
15519            Self::default()
15520        }
15521
15522        unsafe fn decode(
15523            &mut self,
15524            decoder: &mut fidl::encoding::Decoder<'_, D>,
15525            offset: usize,
15526            mut depth: fidl::encoding::Depth,
15527        ) -> fidl::Result<()> {
15528            decoder.debug_check_bounds::<Self>(offset);
15529            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15530                None => return Err(fidl::Error::NotNullable),
15531                Some(len) => len,
15532            };
15533            // Calling decoder.out_of_line_offset(0) is not allowed.
15534            if len == 0 {
15535                return Ok(());
15536            };
15537            depth.increment()?;
15538            let envelope_size = 8;
15539            let bytes_len = len * envelope_size;
15540            let offset = decoder.out_of_line_offset(bytes_len)?;
15541            // Decode the envelope for each type.
15542            let mut _next_ordinal_to_read = 0;
15543            let mut next_offset = offset;
15544            let end_offset = offset + bytes_len;
15545            _next_ordinal_to_read += 1;
15546            if next_offset >= end_offset {
15547                return Ok(());
15548            }
15549
15550            // Decode unknown envelopes for gaps in ordinals.
15551            while _next_ordinal_to_read < 1 {
15552                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15553                _next_ordinal_to_read += 1;
15554                next_offset += envelope_size;
15555            }
15556
15557            let next_out_of_line = decoder.next_out_of_line();
15558            let handles_before = decoder.remaining_handles();
15559            if let Some((inlined, num_bytes, num_handles)) =
15560                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15561            {
15562                let member_inline_size =
15563                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15564                if inlined != (member_inline_size <= 4) {
15565                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15566                }
15567                let inner_offset;
15568                let mut inner_depth = depth.clone();
15569                if inlined {
15570                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15571                    inner_offset = next_offset;
15572                } else {
15573                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15574                    inner_depth.increment()?;
15575                }
15576                let val_ref = self.queries.get_or_insert_with(|| fidl::new_empty!(u32, D));
15577                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
15578                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15579                {
15580                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15581                }
15582                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15583                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15584                }
15585            }
15586
15587            next_offset += envelope_size;
15588            _next_ordinal_to_read += 1;
15589            if next_offset >= end_offset {
15590                return Ok(());
15591            }
15592
15593            // Decode unknown envelopes for gaps in ordinals.
15594            while _next_ordinal_to_read < 2 {
15595                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15596                _next_ordinal_to_read += 1;
15597                next_offset += envelope_size;
15598            }
15599
15600            let next_out_of_line = decoder.next_out_of_line();
15601            let handles_before = decoder.remaining_handles();
15602            if let Some((inlined, num_bytes, num_handles)) =
15603                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15604            {
15605                let member_inline_size =
15606                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15607                if inlined != (member_inline_size <= 4) {
15608                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15609                }
15610                let inner_offset;
15611                let mut inner_depth = depth.clone();
15612                if inlined {
15613                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15614                    inner_offset = next_offset;
15615                } else {
15616                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15617                    inner_depth.increment()?;
15618                }
15619                let val_ref = self.responses.get_or_insert_with(|| fidl::new_empty!(u32, D));
15620                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
15621                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15622                {
15623                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15624                }
15625                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15626                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15627                }
15628            }
15629
15630            next_offset += envelope_size;
15631            _next_ordinal_to_read += 1;
15632            if next_offset >= end_offset {
15633                return Ok(());
15634            }
15635
15636            // Decode unknown envelopes for gaps in ordinals.
15637            while _next_ordinal_to_read < 3 {
15638                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15639                _next_ordinal_to_read += 1;
15640                next_offset += envelope_size;
15641            }
15642
15643            let next_out_of_line = decoder.next_out_of_line();
15644            let handles_before = decoder.remaining_handles();
15645            if let Some((inlined, num_bytes, num_handles)) =
15646                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15647            {
15648                let member_inline_size =
15649                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15650                if inlined != (member_inline_size <= 4) {
15651                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15652                }
15653                let inner_offset;
15654                let mut inner_depth = depth.clone();
15655                if inlined {
15656                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15657                    inner_offset = next_offset;
15658                } else {
15659                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15660                    inner_depth.increment()?;
15661                }
15662                let val_ref = self.failures.get_or_insert_with(|| fidl::new_empty!(u32, D));
15663                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
15664                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15665                {
15666                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15667                }
15668                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15669                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15670                }
15671            }
15672
15673            next_offset += envelope_size;
15674
15675            // Decode the remaining unknown envelopes.
15676            while next_offset < end_offset {
15677                _next_ordinal_to_read += 1;
15678                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15679                next_offset += envelope_size;
15680            }
15681
15682            Ok(())
15683        }
15684    }
15685
15686    impl UpstreamDnsInfo {
15687        #[inline(always)]
15688        fn max_ordinal_present(&self) -> u64 {
15689            if let Some(_) = self.upstream_dns_query_state {
15690                return 1;
15691            }
15692            0
15693        }
15694    }
15695
15696    impl fidl::encoding::ValueTypeMarker for UpstreamDnsInfo {
15697        type Borrowed<'a> = &'a Self;
15698        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15699            value
15700        }
15701    }
15702
15703    unsafe impl fidl::encoding::TypeMarker for UpstreamDnsInfo {
15704        type Owned = Self;
15705
15706        #[inline(always)]
15707        fn inline_align(_context: fidl::encoding::Context) -> usize {
15708            8
15709        }
15710
15711        #[inline(always)]
15712        fn inline_size(_context: fidl::encoding::Context) -> usize {
15713            16
15714        }
15715    }
15716
15717    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UpstreamDnsInfo, D>
15718        for &UpstreamDnsInfo
15719    {
15720        unsafe fn encode(
15721            self,
15722            encoder: &mut fidl::encoding::Encoder<'_, D>,
15723            offset: usize,
15724            mut depth: fidl::encoding::Depth,
15725        ) -> fidl::Result<()> {
15726            encoder.debug_check_bounds::<UpstreamDnsInfo>(offset);
15727            // Vector header
15728            let max_ordinal: u64 = self.max_ordinal_present();
15729            encoder.write_num(max_ordinal, offset);
15730            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15731            // Calling encoder.out_of_line_offset(0) is not allowed.
15732            if max_ordinal == 0 {
15733                return Ok(());
15734            }
15735            depth.increment()?;
15736            let envelope_size = 8;
15737            let bytes_len = max_ordinal as usize * envelope_size;
15738            #[allow(unused_variables)]
15739            let offset = encoder.out_of_line_offset(bytes_len);
15740            let mut _prev_end_offset: usize = 0;
15741            if 1 > max_ordinal {
15742                return Ok(());
15743            }
15744
15745            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15746            // are envelope_size bytes.
15747            let cur_offset: usize = (1 - 1) * envelope_size;
15748
15749            // Zero reserved fields.
15750            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15751
15752            // Safety:
15753            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15754            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15755            //   envelope_size bytes, there is always sufficient room.
15756            fidl::encoding::encode_in_envelope_optional::<UpstreamDnsQueryState, D>(
15757                self.upstream_dns_query_state
15758                    .as_ref()
15759                    .map(<UpstreamDnsQueryState as fidl::encoding::ValueTypeMarker>::borrow),
15760                encoder,
15761                offset + cur_offset,
15762                depth,
15763            )?;
15764
15765            _prev_end_offset = cur_offset + envelope_size;
15766
15767            Ok(())
15768        }
15769    }
15770
15771    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UpstreamDnsInfo {
15772        #[inline(always)]
15773        fn new_empty() -> Self {
15774            Self::default()
15775        }
15776
15777        unsafe fn decode(
15778            &mut self,
15779            decoder: &mut fidl::encoding::Decoder<'_, D>,
15780            offset: usize,
15781            mut depth: fidl::encoding::Depth,
15782        ) -> fidl::Result<()> {
15783            decoder.debug_check_bounds::<Self>(offset);
15784            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15785                None => return Err(fidl::Error::NotNullable),
15786                Some(len) => len,
15787            };
15788            // Calling decoder.out_of_line_offset(0) is not allowed.
15789            if len == 0 {
15790                return Ok(());
15791            };
15792            depth.increment()?;
15793            let envelope_size = 8;
15794            let bytes_len = len * envelope_size;
15795            let offset = decoder.out_of_line_offset(bytes_len)?;
15796            // Decode the envelope for each type.
15797            let mut _next_ordinal_to_read = 0;
15798            let mut next_offset = offset;
15799            let end_offset = offset + bytes_len;
15800            _next_ordinal_to_read += 1;
15801            if next_offset >= end_offset {
15802                return Ok(());
15803            }
15804
15805            // Decode unknown envelopes for gaps in ordinals.
15806            while _next_ordinal_to_read < 1 {
15807                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15808                _next_ordinal_to_read += 1;
15809                next_offset += envelope_size;
15810            }
15811
15812            let next_out_of_line = decoder.next_out_of_line();
15813            let handles_before = decoder.remaining_handles();
15814            if let Some((inlined, num_bytes, num_handles)) =
15815                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15816            {
15817                let member_inline_size =
15818                    <UpstreamDnsQueryState as fidl::encoding::TypeMarker>::inline_size(
15819                        decoder.context,
15820                    );
15821                if inlined != (member_inline_size <= 4) {
15822                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15823                }
15824                let inner_offset;
15825                let mut inner_depth = depth.clone();
15826                if inlined {
15827                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15828                    inner_offset = next_offset;
15829                } else {
15830                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15831                    inner_depth.increment()?;
15832                }
15833                let val_ref = self
15834                    .upstream_dns_query_state
15835                    .get_or_insert_with(|| fidl::new_empty!(UpstreamDnsQueryState, D));
15836                fidl::decode!(
15837                    UpstreamDnsQueryState,
15838                    D,
15839                    val_ref,
15840                    decoder,
15841                    inner_offset,
15842                    inner_depth
15843                )?;
15844                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15845                {
15846                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15847                }
15848                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15849                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15850                }
15851            }
15852
15853            next_offset += envelope_size;
15854
15855            // Decode the remaining unknown envelopes.
15856            while next_offset < end_offset {
15857                _next_ordinal_to_read += 1;
15858                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15859                next_offset += envelope_size;
15860            }
15861
15862            Ok(())
15863        }
15864    }
15865
15866    impl fidl::encoding::ValueTypeMarker for JoinParams {
15867        type Borrowed<'a> = &'a Self;
15868        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15869            value
15870        }
15871    }
15872
15873    unsafe impl fidl::encoding::TypeMarker for JoinParams {
15874        type Owned = Self;
15875
15876        #[inline(always)]
15877        fn inline_align(_context: fidl::encoding::Context) -> usize {
15878            8
15879        }
15880
15881        #[inline(always)]
15882        fn inline_size(_context: fidl::encoding::Context) -> usize {
15883            16
15884        }
15885    }
15886
15887    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<JoinParams, D>
15888        for &JoinParams
15889    {
15890        #[inline]
15891        unsafe fn encode(
15892            self,
15893            encoder: &mut fidl::encoding::Encoder<'_, D>,
15894            offset: usize,
15895            _depth: fidl::encoding::Depth,
15896        ) -> fidl::Result<()> {
15897            encoder.debug_check_bounds::<JoinParams>(offset);
15898            encoder.write_num::<u64>(self.ordinal(), offset);
15899            match self {
15900            JoinParams::ProvisioningParameter(ref val) => {
15901                fidl::encoding::encode_in_envelope::<fidl_fuchsia_lowpan_device__common::ProvisioningParams, D>(
15902                    <fidl_fuchsia_lowpan_device__common::ProvisioningParams as fidl::encoding::ValueTypeMarker>::borrow(val),
15903                    encoder, offset + 8, _depth
15904                )
15905            }
15906            JoinParams::JoinerParameter(ref val) => {
15907                fidl::encoding::encode_in_envelope::<JoinerCommissioningParams, D>(
15908                    <JoinerCommissioningParams as fidl::encoding::ValueTypeMarker>::borrow(val),
15909                    encoder, offset + 8, _depth
15910                )
15911            }
15912            JoinParams::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
15913        }
15914        }
15915    }
15916
15917    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for JoinParams {
15918        #[inline(always)]
15919        fn new_empty() -> Self {
15920            Self::__SourceBreaking { unknown_ordinal: 0 }
15921        }
15922
15923        #[inline]
15924        unsafe fn decode(
15925            &mut self,
15926            decoder: &mut fidl::encoding::Decoder<'_, D>,
15927            offset: usize,
15928            mut depth: fidl::encoding::Depth,
15929        ) -> fidl::Result<()> {
15930            decoder.debug_check_bounds::<Self>(offset);
15931            #[allow(unused_variables)]
15932            let next_out_of_line = decoder.next_out_of_line();
15933            let handles_before = decoder.remaining_handles();
15934            let (ordinal, inlined, num_bytes, num_handles) =
15935                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
15936
15937            let member_inline_size = match ordinal {
15938            1 => <fidl_fuchsia_lowpan_device__common::ProvisioningParams as fidl::encoding::TypeMarker>::inline_size(decoder.context),
15939            2 => <JoinerCommissioningParams as fidl::encoding::TypeMarker>::inline_size(decoder.context),
15940            0 => return Err(fidl::Error::UnknownUnionTag),
15941            _ => num_bytes as usize,
15942        };
15943
15944            if inlined != (member_inline_size <= 4) {
15945                return Err(fidl::Error::InvalidInlineBitInEnvelope);
15946            }
15947            let _inner_offset;
15948            if inlined {
15949                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
15950                _inner_offset = offset + 8;
15951            } else {
15952                depth.increment()?;
15953                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15954            }
15955            match ordinal {
15956                1 => {
15957                    #[allow(irrefutable_let_patterns)]
15958                    if let JoinParams::ProvisioningParameter(_) = self {
15959                        // Do nothing, read the value into the object
15960                    } else {
15961                        // Initialize `self` to the right variant
15962                        *self = JoinParams::ProvisioningParameter(fidl::new_empty!(
15963                            fidl_fuchsia_lowpan_device__common::ProvisioningParams,
15964                            D
15965                        ));
15966                    }
15967                    #[allow(irrefutable_let_patterns)]
15968                    if let JoinParams::ProvisioningParameter(ref mut val) = self {
15969                        fidl::decode!(
15970                            fidl_fuchsia_lowpan_device__common::ProvisioningParams,
15971                            D,
15972                            val,
15973                            decoder,
15974                            _inner_offset,
15975                            depth
15976                        )?;
15977                    } else {
15978                        unreachable!()
15979                    }
15980                }
15981                2 => {
15982                    #[allow(irrefutable_let_patterns)]
15983                    if let JoinParams::JoinerParameter(_) = self {
15984                        // Do nothing, read the value into the object
15985                    } else {
15986                        // Initialize `self` to the right variant
15987                        *self = JoinParams::JoinerParameter(fidl::new_empty!(
15988                            JoinerCommissioningParams,
15989                            D
15990                        ));
15991                    }
15992                    #[allow(irrefutable_let_patterns)]
15993                    if let JoinParams::JoinerParameter(ref mut val) = self {
15994                        fidl::decode!(
15995                            JoinerCommissioningParams,
15996                            D,
15997                            val,
15998                            decoder,
15999                            _inner_offset,
16000                            depth
16001                        )?;
16002                    } else {
16003                        unreachable!()
16004                    }
16005                }
16006                #[allow(deprecated)]
16007                ordinal => {
16008                    for _ in 0..num_handles {
16009                        decoder.drop_next_handle()?;
16010                    }
16011                    *self = JoinParams::__SourceBreaking { unknown_ordinal: ordinal };
16012                }
16013            }
16014            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
16015                return Err(fidl::Error::InvalidNumBytesInEnvelope);
16016            }
16017            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16018                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16019            }
16020            Ok(())
16021        }
16022    }
16023
16024    impl fidl::encoding::ValueTypeMarker for ProvisioningProgress {
16025        type Borrowed<'a> = &'a Self;
16026        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
16027            value
16028        }
16029    }
16030
16031    unsafe impl fidl::encoding::TypeMarker for ProvisioningProgress {
16032        type Owned = Self;
16033
16034        #[inline(always)]
16035        fn inline_align(_context: fidl::encoding::Context) -> usize {
16036            8
16037        }
16038
16039        #[inline(always)]
16040        fn inline_size(_context: fidl::encoding::Context) -> usize {
16041            16
16042        }
16043    }
16044
16045    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProvisioningProgress, D>
16046        for &ProvisioningProgress
16047    {
16048        #[inline]
16049        unsafe fn encode(
16050            self,
16051            encoder: &mut fidl::encoding::Encoder<'_, D>,
16052            offset: usize,
16053            _depth: fidl::encoding::Depth,
16054        ) -> fidl::Result<()> {
16055            encoder.debug_check_bounds::<ProvisioningProgress>(offset);
16056            encoder.write_num::<u64>(self.ordinal(), offset);
16057            match self {
16058            ProvisioningProgress::Progress(ref val) => {
16059                fidl::encoding::encode_in_envelope::<f32, D>(
16060                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16061                    encoder, offset + 8, _depth
16062                )
16063            }
16064            ProvisioningProgress::Identity(ref val) => {
16065                fidl::encoding::encode_in_envelope::<fidl_fuchsia_lowpan_device__common::Identity, D>(
16066                    <fidl_fuchsia_lowpan_device__common::Identity as fidl::encoding::ValueTypeMarker>::borrow(val),
16067                    encoder, offset + 8, _depth
16068                )
16069            }
16070            ProvisioningProgress::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
16071        }
16072        }
16073    }
16074
16075    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProvisioningProgress {
16076        #[inline(always)]
16077        fn new_empty() -> Self {
16078            Self::__SourceBreaking { unknown_ordinal: 0 }
16079        }
16080
16081        #[inline]
16082        unsafe fn decode(
16083            &mut self,
16084            decoder: &mut fidl::encoding::Decoder<'_, D>,
16085            offset: usize,
16086            mut depth: fidl::encoding::Depth,
16087        ) -> fidl::Result<()> {
16088            decoder.debug_check_bounds::<Self>(offset);
16089            #[allow(unused_variables)]
16090            let next_out_of_line = decoder.next_out_of_line();
16091            let handles_before = decoder.remaining_handles();
16092            let (ordinal, inlined, num_bytes, num_handles) =
16093                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
16094
16095            let member_inline_size = match ordinal {
16096            1 => <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16097            2 => <fidl_fuchsia_lowpan_device__common::Identity as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16098            0 => return Err(fidl::Error::UnknownUnionTag),
16099            _ => num_bytes as usize,
16100        };
16101
16102            if inlined != (member_inline_size <= 4) {
16103                return Err(fidl::Error::InvalidInlineBitInEnvelope);
16104            }
16105            let _inner_offset;
16106            if inlined {
16107                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
16108                _inner_offset = offset + 8;
16109            } else {
16110                depth.increment()?;
16111                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16112            }
16113            match ordinal {
16114                1 => {
16115                    #[allow(irrefutable_let_patterns)]
16116                    if let ProvisioningProgress::Progress(_) = self {
16117                        // Do nothing, read the value into the object
16118                    } else {
16119                        // Initialize `self` to the right variant
16120                        *self = ProvisioningProgress::Progress(fidl::new_empty!(f32, D));
16121                    }
16122                    #[allow(irrefutable_let_patterns)]
16123                    if let ProvisioningProgress::Progress(ref mut val) = self {
16124                        fidl::decode!(f32, D, val, decoder, _inner_offset, depth)?;
16125                    } else {
16126                        unreachable!()
16127                    }
16128                }
16129                2 => {
16130                    #[allow(irrefutable_let_patterns)]
16131                    if let ProvisioningProgress::Identity(_) = self {
16132                        // Do nothing, read the value into the object
16133                    } else {
16134                        // Initialize `self` to the right variant
16135                        *self = ProvisioningProgress::Identity(fidl::new_empty!(
16136                            fidl_fuchsia_lowpan_device__common::Identity,
16137                            D
16138                        ));
16139                    }
16140                    #[allow(irrefutable_let_patterns)]
16141                    if let ProvisioningProgress::Identity(ref mut val) = self {
16142                        fidl::decode!(
16143                            fidl_fuchsia_lowpan_device__common::Identity,
16144                            D,
16145                            val,
16146                            decoder,
16147                            _inner_offset,
16148                            depth
16149                        )?;
16150                    } else {
16151                        unreachable!()
16152                    }
16153                }
16154                #[allow(deprecated)]
16155                ordinal => {
16156                    for _ in 0..num_handles {
16157                        decoder.drop_next_handle()?;
16158                    }
16159                    *self = ProvisioningProgress::__SourceBreaking { unknown_ordinal: ordinal };
16160                }
16161            }
16162            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
16163                return Err(fidl::Error::InvalidNumBytesInEnvelope);
16164            }
16165            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16166                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16167            }
16168            Ok(())
16169        }
16170    }
16171}