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
1410pub mod beacon_info_stream_ordinals {
1411    pub const NEXT: u64 = 0x367a557363a340b6;
1412}
1413
1414pub mod device_ordinals {
1415    pub const GET_SUPPORTED_CHANNELS: u64 = 0x2d8b969a9bd70f23;
1416}
1417
1418pub mod device_connector_ordinals {
1419    pub const CONNECT: u64 = 0x296896c9304836cd;
1420}
1421
1422pub mod device_extra_ordinals {
1423    pub const FORM_NETWORK: u64 = 0x6a8135f84bfc90e;
1424    pub const JOIN_NETWORK: u64 = 0x3ea583bab79f81c0;
1425    pub const START_NETWORK_SCAN: u64 = 0x6288c73b79188b40;
1426}
1427
1428pub mod device_extra_connector_ordinals {
1429    pub const CONNECT: u64 = 0x3fcb37e4226c81e9;
1430}
1431
1432pub mod device_route_ordinals {
1433    pub const REGISTER_ON_MESH_PREFIX: u64 = 0x2c4135231eb97f61;
1434    pub const UNREGISTER_ON_MESH_PREFIX: u64 = 0x82d5184028b797f;
1435    pub const REGISTER_EXTERNAL_ROUTE: u64 = 0x75f70f0fc34a5a73;
1436    pub const UNREGISTER_EXTERNAL_ROUTE: u64 = 0x3769be353b1d7088;
1437}
1438
1439pub mod device_route_connector_ordinals {
1440    pub const CONNECT: u64 = 0x19cd5fdcb971f4ac;
1441}
1442
1443pub mod device_route_extra_ordinals {
1444    pub const GET_LOCAL_ON_MESH_PREFIXES: u64 = 0xf192c43311c811;
1445    pub const GET_LOCAL_EXTERNAL_ROUTES: u64 = 0x5a688c2e62c766a6;
1446}
1447
1448pub mod device_route_extra_connector_ordinals {
1449    pub const CONNECT: u64 = 0x12f72df7b1348fe2;
1450}
1451
1452pub mod legacy_joining_ordinals {
1453    pub const MAKE_JOINABLE: u64 = 0x1739a6ae36d5c5aa;
1454}
1455
1456pub mod legacy_joining_connector_ordinals {
1457    pub const CONNECT: u64 = 0x3c8dfeb943bb8d06;
1458}
1459
1460pub mod provisioning_monitor_ordinals {
1461    pub const WATCH_PROGRESS: u64 = 0xc35336fc43ac0c;
1462}
1463
1464pub mod telemetry_provider_ordinals {
1465    pub const GET_TELEMETRY: u64 = 0xc34f2fff7dacc41;
1466}
1467
1468pub mod telemetry_provider_connector_ordinals {
1469    pub const CONNECT: u64 = 0x24a5bf1be73e2fad;
1470}
1471
1472mod internal {
1473    use super::*;
1474    unsafe impl fidl::encoding::TypeMarker for Dhcp6PdState {
1475        type Owned = Self;
1476
1477        #[inline(always)]
1478        fn inline_align(_context: fidl::encoding::Context) -> usize {
1479            std::mem::align_of::<u32>()
1480        }
1481
1482        #[inline(always)]
1483        fn inline_size(_context: fidl::encoding::Context) -> usize {
1484            std::mem::size_of::<u32>()
1485        }
1486
1487        #[inline(always)]
1488        fn encode_is_copy() -> bool {
1489            false
1490        }
1491
1492        #[inline(always)]
1493        fn decode_is_copy() -> bool {
1494            false
1495        }
1496    }
1497
1498    impl fidl::encoding::ValueTypeMarker for Dhcp6PdState {
1499        type Borrowed<'a> = Self;
1500        #[inline(always)]
1501        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1502            *value
1503        }
1504    }
1505
1506    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Dhcp6PdState {
1507        #[inline]
1508        unsafe fn encode(
1509            self,
1510            encoder: &mut fidl::encoding::Encoder<'_, D>,
1511            offset: usize,
1512            _depth: fidl::encoding::Depth,
1513        ) -> fidl::Result<()> {
1514            encoder.debug_check_bounds::<Self>(offset);
1515            encoder.write_num(self.into_primitive(), offset);
1516            Ok(())
1517        }
1518    }
1519
1520    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Dhcp6PdState {
1521        #[inline(always)]
1522        fn new_empty() -> Self {
1523            Self::unknown()
1524        }
1525
1526        #[inline]
1527        unsafe fn decode(
1528            &mut self,
1529            decoder: &mut fidl::encoding::Decoder<'_, D>,
1530            offset: usize,
1531            _depth: fidl::encoding::Depth,
1532        ) -> fidl::Result<()> {
1533            decoder.debug_check_bounds::<Self>(offset);
1534            let prim = decoder.read_num::<u32>(offset);
1535
1536            *self = Self::from_primitive_allow_unknown(prim);
1537            Ok(())
1538        }
1539    }
1540    unsafe impl fidl::encoding::TypeMarker for Nat64State {
1541        type Owned = Self;
1542
1543        #[inline(always)]
1544        fn inline_align(_context: fidl::encoding::Context) -> usize {
1545            std::mem::align_of::<u32>()
1546        }
1547
1548        #[inline(always)]
1549        fn inline_size(_context: fidl::encoding::Context) -> usize {
1550            std::mem::size_of::<u32>()
1551        }
1552
1553        #[inline(always)]
1554        fn encode_is_copy() -> bool {
1555            false
1556        }
1557
1558        #[inline(always)]
1559        fn decode_is_copy() -> bool {
1560            false
1561        }
1562    }
1563
1564    impl fidl::encoding::ValueTypeMarker for Nat64State {
1565        type Borrowed<'a> = Self;
1566        #[inline(always)]
1567        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1568            *value
1569        }
1570    }
1571
1572    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for Nat64State {
1573        #[inline]
1574        unsafe fn encode(
1575            self,
1576            encoder: &mut fidl::encoding::Encoder<'_, D>,
1577            offset: usize,
1578            _depth: fidl::encoding::Depth,
1579        ) -> fidl::Result<()> {
1580            encoder.debug_check_bounds::<Self>(offset);
1581            encoder.write_num(self.into_primitive(), offset);
1582            Ok(())
1583        }
1584    }
1585
1586    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64State {
1587        #[inline(always)]
1588        fn new_empty() -> Self {
1589            Self::unknown()
1590        }
1591
1592        #[inline]
1593        unsafe fn decode(
1594            &mut self,
1595            decoder: &mut fidl::encoding::Decoder<'_, D>,
1596            offset: usize,
1597            _depth: fidl::encoding::Depth,
1598        ) -> fidl::Result<()> {
1599            decoder.debug_check_bounds::<Self>(offset);
1600            let prim = decoder.read_num::<u32>(offset);
1601
1602            *self = Self::from_primitive_allow_unknown(prim);
1603            Ok(())
1604        }
1605    }
1606    unsafe impl fidl::encoding::TypeMarker for ProvisionError {
1607        type Owned = Self;
1608
1609        #[inline(always)]
1610        fn inline_align(_context: fidl::encoding::Context) -> usize {
1611            std::mem::align_of::<i32>()
1612        }
1613
1614        #[inline(always)]
1615        fn inline_size(_context: fidl::encoding::Context) -> usize {
1616            std::mem::size_of::<i32>()
1617        }
1618
1619        #[inline(always)]
1620        fn encode_is_copy() -> bool {
1621            false
1622        }
1623
1624        #[inline(always)]
1625        fn decode_is_copy() -> bool {
1626            false
1627        }
1628    }
1629
1630    impl fidl::encoding::ValueTypeMarker for ProvisionError {
1631        type Borrowed<'a> = Self;
1632        #[inline(always)]
1633        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1634            *value
1635        }
1636    }
1637
1638    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ProvisionError {
1639        #[inline]
1640        unsafe fn encode(
1641            self,
1642            encoder: &mut fidl::encoding::Encoder<'_, D>,
1643            offset: usize,
1644            _depth: fidl::encoding::Depth,
1645        ) -> fidl::Result<()> {
1646            encoder.debug_check_bounds::<Self>(offset);
1647            encoder.write_num(self.into_primitive(), offset);
1648            Ok(())
1649        }
1650    }
1651
1652    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProvisionError {
1653        #[inline(always)]
1654        fn new_empty() -> Self {
1655            Self::unknown()
1656        }
1657
1658        #[inline]
1659        unsafe fn decode(
1660            &mut self,
1661            decoder: &mut fidl::encoding::Decoder<'_, D>,
1662            offset: usize,
1663            _depth: fidl::encoding::Depth,
1664        ) -> fidl::Result<()> {
1665            decoder.debug_check_bounds::<Self>(offset);
1666            let prim = decoder.read_num::<i32>(offset);
1667
1668            *self = Self::from_primitive_allow_unknown(prim);
1669            Ok(())
1670        }
1671    }
1672    unsafe impl fidl::encoding::TypeMarker for RoutePreference {
1673        type Owned = Self;
1674
1675        #[inline(always)]
1676        fn inline_align(_context: fidl::encoding::Context) -> usize {
1677            std::mem::align_of::<i8>()
1678        }
1679
1680        #[inline(always)]
1681        fn inline_size(_context: fidl::encoding::Context) -> usize {
1682            std::mem::size_of::<i8>()
1683        }
1684
1685        #[inline(always)]
1686        fn encode_is_copy() -> bool {
1687            true
1688        }
1689
1690        #[inline(always)]
1691        fn decode_is_copy() -> bool {
1692            false
1693        }
1694    }
1695
1696    impl fidl::encoding::ValueTypeMarker for RoutePreference {
1697        type Borrowed<'a> = Self;
1698        #[inline(always)]
1699        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1700            *value
1701        }
1702    }
1703
1704    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1705        for RoutePreference
1706    {
1707        #[inline]
1708        unsafe fn encode(
1709            self,
1710            encoder: &mut fidl::encoding::Encoder<'_, D>,
1711            offset: usize,
1712            _depth: fidl::encoding::Depth,
1713        ) -> fidl::Result<()> {
1714            encoder.debug_check_bounds::<Self>(offset);
1715            encoder.write_num(self.into_primitive(), offset);
1716            Ok(())
1717        }
1718    }
1719
1720    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RoutePreference {
1721        #[inline(always)]
1722        fn new_empty() -> Self {
1723            Self::Low
1724        }
1725
1726        #[inline]
1727        unsafe fn decode(
1728            &mut self,
1729            decoder: &mut fidl::encoding::Decoder<'_, D>,
1730            offset: usize,
1731            _depth: fidl::encoding::Depth,
1732        ) -> fidl::Result<()> {
1733            decoder.debug_check_bounds::<Self>(offset);
1734            let prim = decoder.read_num::<i8>(offset);
1735
1736            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1737            Ok(())
1738        }
1739    }
1740    unsafe impl fidl::encoding::TypeMarker for SrpServerAddressMode {
1741        type Owned = Self;
1742
1743        #[inline(always)]
1744        fn inline_align(_context: fidl::encoding::Context) -> usize {
1745            std::mem::align_of::<u32>()
1746        }
1747
1748        #[inline(always)]
1749        fn inline_size(_context: fidl::encoding::Context) -> usize {
1750            std::mem::size_of::<u32>()
1751        }
1752
1753        #[inline(always)]
1754        fn encode_is_copy() -> bool {
1755            true
1756        }
1757
1758        #[inline(always)]
1759        fn decode_is_copy() -> bool {
1760            false
1761        }
1762    }
1763
1764    impl fidl::encoding::ValueTypeMarker for SrpServerAddressMode {
1765        type Borrowed<'a> = Self;
1766        #[inline(always)]
1767        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1768            *value
1769        }
1770    }
1771
1772    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1773        for SrpServerAddressMode
1774    {
1775        #[inline]
1776        unsafe fn encode(
1777            self,
1778            encoder: &mut fidl::encoding::Encoder<'_, D>,
1779            offset: usize,
1780            _depth: fidl::encoding::Depth,
1781        ) -> fidl::Result<()> {
1782            encoder.debug_check_bounds::<Self>(offset);
1783            encoder.write_num(self.into_primitive(), offset);
1784            Ok(())
1785        }
1786    }
1787
1788    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SrpServerAddressMode {
1789        #[inline(always)]
1790        fn new_empty() -> Self {
1791            Self::Unicast
1792        }
1793
1794        #[inline]
1795        unsafe fn decode(
1796            &mut self,
1797            decoder: &mut fidl::encoding::Decoder<'_, D>,
1798            offset: usize,
1799            _depth: fidl::encoding::Depth,
1800        ) -> fidl::Result<()> {
1801            decoder.debug_check_bounds::<Self>(offset);
1802            let prim = decoder.read_num::<u32>(offset);
1803
1804            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1805            Ok(())
1806        }
1807    }
1808    unsafe impl fidl::encoding::TypeMarker for SrpServerState {
1809        type Owned = Self;
1810
1811        #[inline(always)]
1812        fn inline_align(_context: fidl::encoding::Context) -> usize {
1813            std::mem::align_of::<u32>()
1814        }
1815
1816        #[inline(always)]
1817        fn inline_size(_context: fidl::encoding::Context) -> usize {
1818            std::mem::size_of::<u32>()
1819        }
1820
1821        #[inline(always)]
1822        fn encode_is_copy() -> bool {
1823            true
1824        }
1825
1826        #[inline(always)]
1827        fn decode_is_copy() -> bool {
1828            false
1829        }
1830    }
1831
1832    impl fidl::encoding::ValueTypeMarker for SrpServerState {
1833        type Borrowed<'a> = Self;
1834        #[inline(always)]
1835        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1836            *value
1837        }
1838    }
1839
1840    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for SrpServerState {
1841        #[inline]
1842        unsafe fn encode(
1843            self,
1844            encoder: &mut fidl::encoding::Encoder<'_, D>,
1845            offset: usize,
1846            _depth: fidl::encoding::Depth,
1847        ) -> fidl::Result<()> {
1848            encoder.debug_check_bounds::<Self>(offset);
1849            encoder.write_num(self.into_primitive(), offset);
1850            Ok(())
1851        }
1852    }
1853
1854    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SrpServerState {
1855        #[inline(always)]
1856        fn new_empty() -> Self {
1857            Self::Disabled
1858        }
1859
1860        #[inline]
1861        unsafe fn decode(
1862            &mut self,
1863            decoder: &mut fidl::encoding::Decoder<'_, D>,
1864            offset: usize,
1865            _depth: fidl::encoding::Depth,
1866        ) -> fidl::Result<()> {
1867            decoder.debug_check_bounds::<Self>(offset);
1868            let prim = decoder.read_num::<u32>(offset);
1869
1870            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1871            Ok(())
1872        }
1873    }
1874    unsafe impl fidl::encoding::TypeMarker for UpstreamDnsQueryState {
1875        type Owned = Self;
1876
1877        #[inline(always)]
1878        fn inline_align(_context: fidl::encoding::Context) -> usize {
1879            std::mem::align_of::<u32>()
1880        }
1881
1882        #[inline(always)]
1883        fn inline_size(_context: fidl::encoding::Context) -> usize {
1884            std::mem::size_of::<u32>()
1885        }
1886
1887        #[inline(always)]
1888        fn encode_is_copy() -> bool {
1889            false
1890        }
1891
1892        #[inline(always)]
1893        fn decode_is_copy() -> bool {
1894            false
1895        }
1896    }
1897
1898    impl fidl::encoding::ValueTypeMarker for UpstreamDnsQueryState {
1899        type Borrowed<'a> = Self;
1900        #[inline(always)]
1901        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1902            *value
1903        }
1904    }
1905
1906    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1907        for UpstreamDnsQueryState
1908    {
1909        #[inline]
1910        unsafe fn encode(
1911            self,
1912            encoder: &mut fidl::encoding::Encoder<'_, D>,
1913            offset: usize,
1914            _depth: fidl::encoding::Depth,
1915        ) -> fidl::Result<()> {
1916            encoder.debug_check_bounds::<Self>(offset);
1917            encoder.write_num(self.into_primitive(), offset);
1918            Ok(())
1919        }
1920    }
1921
1922    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UpstreamDnsQueryState {
1923        #[inline(always)]
1924        fn new_empty() -> Self {
1925            Self::unknown()
1926        }
1927
1928        #[inline]
1929        unsafe fn decode(
1930            &mut self,
1931            decoder: &mut fidl::encoding::Decoder<'_, D>,
1932            offset: usize,
1933            _depth: fidl::encoding::Depth,
1934        ) -> fidl::Result<()> {
1935            decoder.debug_check_bounds::<Self>(offset);
1936            let prim = decoder.read_num::<u32>(offset);
1937
1938            *self = Self::from_primitive_allow_unknown(prim);
1939            Ok(())
1940        }
1941    }
1942
1943    impl fidl::encoding::ValueTypeMarker for BeaconInfoStreamNextResponse {
1944        type Borrowed<'a> = &'a Self;
1945        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1946            value
1947        }
1948    }
1949
1950    unsafe impl fidl::encoding::TypeMarker for BeaconInfoStreamNextResponse {
1951        type Owned = Self;
1952
1953        #[inline(always)]
1954        fn inline_align(_context: fidl::encoding::Context) -> usize {
1955            8
1956        }
1957
1958        #[inline(always)]
1959        fn inline_size(_context: fidl::encoding::Context) -> usize {
1960            16
1961        }
1962    }
1963
1964    unsafe impl<D: fidl::encoding::ResourceDialect>
1965        fidl::encoding::Encode<BeaconInfoStreamNextResponse, D> for &BeaconInfoStreamNextResponse
1966    {
1967        #[inline]
1968        unsafe fn encode(
1969            self,
1970            encoder: &mut fidl::encoding::Encoder<'_, D>,
1971            offset: usize,
1972            _depth: fidl::encoding::Depth,
1973        ) -> fidl::Result<()> {
1974            encoder.debug_check_bounds::<BeaconInfoStreamNextResponse>(offset);
1975            // Delegate to tuple encoding.
1976            fidl::encoding::Encode::<BeaconInfoStreamNextResponse, D>::encode(
1977                (
1978                    <fidl::encoding::Vector<BeaconInfo, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.beacons),
1979                ),
1980                encoder, offset, _depth
1981            )
1982        }
1983    }
1984    unsafe impl<
1985            D: fidl::encoding::ResourceDialect,
1986            T0: fidl::encoding::Encode<fidl::encoding::Vector<BeaconInfo, 32>, D>,
1987        > fidl::encoding::Encode<BeaconInfoStreamNextResponse, D> for (T0,)
1988    {
1989        #[inline]
1990        unsafe fn encode(
1991            self,
1992            encoder: &mut fidl::encoding::Encoder<'_, D>,
1993            offset: usize,
1994            depth: fidl::encoding::Depth,
1995        ) -> fidl::Result<()> {
1996            encoder.debug_check_bounds::<BeaconInfoStreamNextResponse>(offset);
1997            // Zero out padding regions. There's no need to apply masks
1998            // because the unmasked parts will be overwritten by fields.
1999            // Write the fields.
2000            self.0.encode(encoder, offset + 0, depth)?;
2001            Ok(())
2002        }
2003    }
2004
2005    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2006        for BeaconInfoStreamNextResponse
2007    {
2008        #[inline(always)]
2009        fn new_empty() -> Self {
2010            Self { beacons: fidl::new_empty!(fidl::encoding::Vector<BeaconInfo, 32>, D) }
2011        }
2012
2013        #[inline]
2014        unsafe fn decode(
2015            &mut self,
2016            decoder: &mut fidl::encoding::Decoder<'_, D>,
2017            offset: usize,
2018            _depth: fidl::encoding::Depth,
2019        ) -> fidl::Result<()> {
2020            decoder.debug_check_bounds::<Self>(offset);
2021            // Verify that padding bytes are zero.
2022            fidl::decode!(fidl::encoding::Vector<BeaconInfo, 32>, D, &mut self.beacons, decoder, offset + 0, _depth)?;
2023            Ok(())
2024        }
2025    }
2026
2027    impl fidl::encoding::ValueTypeMarker for DeviceGetSupportedChannelsResponse {
2028        type Borrowed<'a> = &'a Self;
2029        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2030            value
2031        }
2032    }
2033
2034    unsafe impl fidl::encoding::TypeMarker for DeviceGetSupportedChannelsResponse {
2035        type Owned = Self;
2036
2037        #[inline(always)]
2038        fn inline_align(_context: fidl::encoding::Context) -> usize {
2039            8
2040        }
2041
2042        #[inline(always)]
2043        fn inline_size(_context: fidl::encoding::Context) -> usize {
2044            16
2045        }
2046    }
2047
2048    unsafe impl<D: fidl::encoding::ResourceDialect>
2049        fidl::encoding::Encode<DeviceGetSupportedChannelsResponse, D>
2050        for &DeviceGetSupportedChannelsResponse
2051    {
2052        #[inline]
2053        unsafe fn encode(
2054            self,
2055            encoder: &mut fidl::encoding::Encoder<'_, D>,
2056            offset: usize,
2057            _depth: fidl::encoding::Depth,
2058        ) -> fidl::Result<()> {
2059            encoder.debug_check_bounds::<DeviceGetSupportedChannelsResponse>(offset);
2060            // Delegate to tuple encoding.
2061            fidl::encoding::Encode::<DeviceGetSupportedChannelsResponse, D>::encode(
2062                (
2063                    <fidl::encoding::Vector<ChannelInfo, 200> as fidl::encoding::ValueTypeMarker>::borrow(&self.channels_info),
2064                ),
2065                encoder, offset, _depth
2066            )
2067        }
2068    }
2069    unsafe impl<
2070            D: fidl::encoding::ResourceDialect,
2071            T0: fidl::encoding::Encode<fidl::encoding::Vector<ChannelInfo, 200>, D>,
2072        > fidl::encoding::Encode<DeviceGetSupportedChannelsResponse, D> for (T0,)
2073    {
2074        #[inline]
2075        unsafe fn encode(
2076            self,
2077            encoder: &mut fidl::encoding::Encoder<'_, D>,
2078            offset: usize,
2079            depth: fidl::encoding::Depth,
2080        ) -> fidl::Result<()> {
2081            encoder.debug_check_bounds::<DeviceGetSupportedChannelsResponse>(offset);
2082            // Zero out padding regions. There's no need to apply masks
2083            // because the unmasked parts will be overwritten by fields.
2084            // Write the fields.
2085            self.0.encode(encoder, offset + 0, depth)?;
2086            Ok(())
2087        }
2088    }
2089
2090    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2091        for DeviceGetSupportedChannelsResponse
2092    {
2093        #[inline(always)]
2094        fn new_empty() -> Self {
2095            Self { channels_info: fidl::new_empty!(fidl::encoding::Vector<ChannelInfo, 200>, D) }
2096        }
2097
2098        #[inline]
2099        unsafe fn decode(
2100            &mut self,
2101            decoder: &mut fidl::encoding::Decoder<'_, D>,
2102            offset: usize,
2103            _depth: fidl::encoding::Depth,
2104        ) -> fidl::Result<()> {
2105            decoder.debug_check_bounds::<Self>(offset);
2106            // Verify that padding bytes are zero.
2107            fidl::decode!(fidl::encoding::Vector<ChannelInfo, 200>, D, &mut self.channels_info, decoder, offset + 0, _depth)?;
2108            Ok(())
2109        }
2110    }
2111
2112    impl fidl::encoding::ValueTypeMarker for DeviceRouteExtraGetLocalExternalRoutesResponse {
2113        type Borrowed<'a> = &'a Self;
2114        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2115            value
2116        }
2117    }
2118
2119    unsafe impl fidl::encoding::TypeMarker for DeviceRouteExtraGetLocalExternalRoutesResponse {
2120        type Owned = Self;
2121
2122        #[inline(always)]
2123        fn inline_align(_context: fidl::encoding::Context) -> usize {
2124            8
2125        }
2126
2127        #[inline(always)]
2128        fn inline_size(_context: fidl::encoding::Context) -> usize {
2129            16
2130        }
2131    }
2132
2133    unsafe impl<D: fidl::encoding::ResourceDialect>
2134        fidl::encoding::Encode<DeviceRouteExtraGetLocalExternalRoutesResponse, D>
2135        for &DeviceRouteExtraGetLocalExternalRoutesResponse
2136    {
2137        #[inline]
2138        unsafe fn encode(
2139            self,
2140            encoder: &mut fidl::encoding::Encoder<'_, D>,
2141            offset: usize,
2142            _depth: fidl::encoding::Depth,
2143        ) -> fidl::Result<()> {
2144            encoder.debug_check_bounds::<DeviceRouteExtraGetLocalExternalRoutesResponse>(offset);
2145            // Delegate to tuple encoding.
2146            fidl::encoding::Encode::<DeviceRouteExtraGetLocalExternalRoutesResponse, D>::encode(
2147                (
2148                    <fidl::encoding::Vector<ExternalRoute, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.external_routes),
2149                ),
2150                encoder, offset, _depth
2151            )
2152        }
2153    }
2154    unsafe impl<
2155            D: fidl::encoding::ResourceDialect,
2156            T0: fidl::encoding::Encode<fidl::encoding::Vector<ExternalRoute, 32>, D>,
2157        > fidl::encoding::Encode<DeviceRouteExtraGetLocalExternalRoutesResponse, D> for (T0,)
2158    {
2159        #[inline]
2160        unsafe fn encode(
2161            self,
2162            encoder: &mut fidl::encoding::Encoder<'_, D>,
2163            offset: usize,
2164            depth: fidl::encoding::Depth,
2165        ) -> fidl::Result<()> {
2166            encoder.debug_check_bounds::<DeviceRouteExtraGetLocalExternalRoutesResponse>(offset);
2167            // Zero out padding regions. There's no need to apply masks
2168            // because the unmasked parts will be overwritten by fields.
2169            // Write the fields.
2170            self.0.encode(encoder, offset + 0, depth)?;
2171            Ok(())
2172        }
2173    }
2174
2175    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2176        for DeviceRouteExtraGetLocalExternalRoutesResponse
2177    {
2178        #[inline(always)]
2179        fn new_empty() -> Self {
2180            Self { external_routes: fidl::new_empty!(fidl::encoding::Vector<ExternalRoute, 32>, D) }
2181        }
2182
2183        #[inline]
2184        unsafe fn decode(
2185            &mut self,
2186            decoder: &mut fidl::encoding::Decoder<'_, D>,
2187            offset: usize,
2188            _depth: fidl::encoding::Depth,
2189        ) -> fidl::Result<()> {
2190            decoder.debug_check_bounds::<Self>(offset);
2191            // Verify that padding bytes are zero.
2192            fidl::decode!(fidl::encoding::Vector<ExternalRoute, 32>, D, &mut self.external_routes, decoder, offset + 0, _depth)?;
2193            Ok(())
2194        }
2195    }
2196
2197    impl fidl::encoding::ValueTypeMarker for DeviceRouteExtraGetLocalOnMeshPrefixesResponse {
2198        type Borrowed<'a> = &'a Self;
2199        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2200            value
2201        }
2202    }
2203
2204    unsafe impl fidl::encoding::TypeMarker for DeviceRouteExtraGetLocalOnMeshPrefixesResponse {
2205        type Owned = Self;
2206
2207        #[inline(always)]
2208        fn inline_align(_context: fidl::encoding::Context) -> usize {
2209            8
2210        }
2211
2212        #[inline(always)]
2213        fn inline_size(_context: fidl::encoding::Context) -> usize {
2214            16
2215        }
2216    }
2217
2218    unsafe impl<D: fidl::encoding::ResourceDialect>
2219        fidl::encoding::Encode<DeviceRouteExtraGetLocalOnMeshPrefixesResponse, D>
2220        for &DeviceRouteExtraGetLocalOnMeshPrefixesResponse
2221    {
2222        #[inline]
2223        unsafe fn encode(
2224            self,
2225            encoder: &mut fidl::encoding::Encoder<'_, D>,
2226            offset: usize,
2227            _depth: fidl::encoding::Depth,
2228        ) -> fidl::Result<()> {
2229            encoder.debug_check_bounds::<DeviceRouteExtraGetLocalOnMeshPrefixesResponse>(offset);
2230            // Delegate to tuple encoding.
2231            fidl::encoding::Encode::<DeviceRouteExtraGetLocalOnMeshPrefixesResponse, D>::encode(
2232                (
2233                    <fidl::encoding::Vector<OnMeshPrefix, 32> as fidl::encoding::ValueTypeMarker>::borrow(&self.prefixes),
2234                ),
2235                encoder, offset, _depth
2236            )
2237        }
2238    }
2239    unsafe impl<
2240            D: fidl::encoding::ResourceDialect,
2241            T0: fidl::encoding::Encode<fidl::encoding::Vector<OnMeshPrefix, 32>, D>,
2242        > fidl::encoding::Encode<DeviceRouteExtraGetLocalOnMeshPrefixesResponse, D> for (T0,)
2243    {
2244        #[inline]
2245        unsafe fn encode(
2246            self,
2247            encoder: &mut fidl::encoding::Encoder<'_, D>,
2248            offset: usize,
2249            depth: fidl::encoding::Depth,
2250        ) -> fidl::Result<()> {
2251            encoder.debug_check_bounds::<DeviceRouteExtraGetLocalOnMeshPrefixesResponse>(offset);
2252            // Zero out padding regions. There's no need to apply masks
2253            // because the unmasked parts will be overwritten by fields.
2254            // Write the fields.
2255            self.0.encode(encoder, offset + 0, depth)?;
2256            Ok(())
2257        }
2258    }
2259
2260    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2261        for DeviceRouteExtraGetLocalOnMeshPrefixesResponse
2262    {
2263        #[inline(always)]
2264        fn new_empty() -> Self {
2265            Self { prefixes: fidl::new_empty!(fidl::encoding::Vector<OnMeshPrefix, 32>, D) }
2266        }
2267
2268        #[inline]
2269        unsafe fn decode(
2270            &mut self,
2271            decoder: &mut fidl::encoding::Decoder<'_, D>,
2272            offset: usize,
2273            _depth: fidl::encoding::Depth,
2274        ) -> fidl::Result<()> {
2275            decoder.debug_check_bounds::<Self>(offset);
2276            // Verify that padding bytes are zero.
2277            fidl::decode!(fidl::encoding::Vector<OnMeshPrefix, 32>, D, &mut self.prefixes, decoder, offset + 0, _depth)?;
2278            Ok(())
2279        }
2280    }
2281
2282    impl fidl::encoding::ValueTypeMarker for DeviceRouteRegisterExternalRouteRequest {
2283        type Borrowed<'a> = &'a Self;
2284        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2285            value
2286        }
2287    }
2288
2289    unsafe impl fidl::encoding::TypeMarker for DeviceRouteRegisterExternalRouteRequest {
2290        type Owned = Self;
2291
2292        #[inline(always)]
2293        fn inline_align(_context: fidl::encoding::Context) -> usize {
2294            8
2295        }
2296
2297        #[inline(always)]
2298        fn inline_size(_context: fidl::encoding::Context) -> usize {
2299            16
2300        }
2301    }
2302
2303    unsafe impl<D: fidl::encoding::ResourceDialect>
2304        fidl::encoding::Encode<DeviceRouteRegisterExternalRouteRequest, D>
2305        for &DeviceRouteRegisterExternalRouteRequest
2306    {
2307        #[inline]
2308        unsafe fn encode(
2309            self,
2310            encoder: &mut fidl::encoding::Encoder<'_, D>,
2311            offset: usize,
2312            _depth: fidl::encoding::Depth,
2313        ) -> fidl::Result<()> {
2314            encoder.debug_check_bounds::<DeviceRouteRegisterExternalRouteRequest>(offset);
2315            // Delegate to tuple encoding.
2316            fidl::encoding::Encode::<DeviceRouteRegisterExternalRouteRequest, D>::encode(
2317                (<ExternalRoute as fidl::encoding::ValueTypeMarker>::borrow(&self.external_route),),
2318                encoder,
2319                offset,
2320                _depth,
2321            )
2322        }
2323    }
2324    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ExternalRoute, D>>
2325        fidl::encoding::Encode<DeviceRouteRegisterExternalRouteRequest, D> for (T0,)
2326    {
2327        #[inline]
2328        unsafe fn encode(
2329            self,
2330            encoder: &mut fidl::encoding::Encoder<'_, D>,
2331            offset: usize,
2332            depth: fidl::encoding::Depth,
2333        ) -> fidl::Result<()> {
2334            encoder.debug_check_bounds::<DeviceRouteRegisterExternalRouteRequest>(offset);
2335            // Zero out padding regions. There's no need to apply masks
2336            // because the unmasked parts will be overwritten by fields.
2337            // Write the fields.
2338            self.0.encode(encoder, offset + 0, depth)?;
2339            Ok(())
2340        }
2341    }
2342
2343    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2344        for DeviceRouteRegisterExternalRouteRequest
2345    {
2346        #[inline(always)]
2347        fn new_empty() -> Self {
2348            Self { external_route: fidl::new_empty!(ExternalRoute, D) }
2349        }
2350
2351        #[inline]
2352        unsafe fn decode(
2353            &mut self,
2354            decoder: &mut fidl::encoding::Decoder<'_, D>,
2355            offset: usize,
2356            _depth: fidl::encoding::Depth,
2357        ) -> fidl::Result<()> {
2358            decoder.debug_check_bounds::<Self>(offset);
2359            // Verify that padding bytes are zero.
2360            fidl::decode!(ExternalRoute, D, &mut self.external_route, decoder, offset + 0, _depth)?;
2361            Ok(())
2362        }
2363    }
2364
2365    impl fidl::encoding::ValueTypeMarker for DeviceRouteRegisterOnMeshPrefixRequest {
2366        type Borrowed<'a> = &'a Self;
2367        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2368            value
2369        }
2370    }
2371
2372    unsafe impl fidl::encoding::TypeMarker for DeviceRouteRegisterOnMeshPrefixRequest {
2373        type Owned = Self;
2374
2375        #[inline(always)]
2376        fn inline_align(_context: fidl::encoding::Context) -> usize {
2377            8
2378        }
2379
2380        #[inline(always)]
2381        fn inline_size(_context: fidl::encoding::Context) -> usize {
2382            16
2383        }
2384    }
2385
2386    unsafe impl<D: fidl::encoding::ResourceDialect>
2387        fidl::encoding::Encode<DeviceRouteRegisterOnMeshPrefixRequest, D>
2388        for &DeviceRouteRegisterOnMeshPrefixRequest
2389    {
2390        #[inline]
2391        unsafe fn encode(
2392            self,
2393            encoder: &mut fidl::encoding::Encoder<'_, D>,
2394            offset: usize,
2395            _depth: fidl::encoding::Depth,
2396        ) -> fidl::Result<()> {
2397            encoder.debug_check_bounds::<DeviceRouteRegisterOnMeshPrefixRequest>(offset);
2398            // Delegate to tuple encoding.
2399            fidl::encoding::Encode::<DeviceRouteRegisterOnMeshPrefixRequest, D>::encode(
2400                (<OnMeshPrefix as fidl::encoding::ValueTypeMarker>::borrow(&self.prefix),),
2401                encoder,
2402                offset,
2403                _depth,
2404            )
2405        }
2406    }
2407    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<OnMeshPrefix, D>>
2408        fidl::encoding::Encode<DeviceRouteRegisterOnMeshPrefixRequest, D> for (T0,)
2409    {
2410        #[inline]
2411        unsafe fn encode(
2412            self,
2413            encoder: &mut fidl::encoding::Encoder<'_, D>,
2414            offset: usize,
2415            depth: fidl::encoding::Depth,
2416        ) -> fidl::Result<()> {
2417            encoder.debug_check_bounds::<DeviceRouteRegisterOnMeshPrefixRequest>(offset);
2418            // Zero out padding regions. There's no need to apply masks
2419            // because the unmasked parts will be overwritten by fields.
2420            // Write the fields.
2421            self.0.encode(encoder, offset + 0, depth)?;
2422            Ok(())
2423        }
2424    }
2425
2426    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2427        for DeviceRouteRegisterOnMeshPrefixRequest
2428    {
2429        #[inline(always)]
2430        fn new_empty() -> Self {
2431            Self { prefix: fidl::new_empty!(OnMeshPrefix, D) }
2432        }
2433
2434        #[inline]
2435        unsafe fn decode(
2436            &mut self,
2437            decoder: &mut fidl::encoding::Decoder<'_, D>,
2438            offset: usize,
2439            _depth: fidl::encoding::Depth,
2440        ) -> fidl::Result<()> {
2441            decoder.debug_check_bounds::<Self>(offset);
2442            // Verify that padding bytes are zero.
2443            fidl::decode!(OnMeshPrefix, D, &mut self.prefix, decoder, offset + 0, _depth)?;
2444            Ok(())
2445        }
2446    }
2447
2448    impl fidl::encoding::ValueTypeMarker for DeviceRouteUnregisterExternalRouteRequest {
2449        type Borrowed<'a> = &'a Self;
2450        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2451            value
2452        }
2453    }
2454
2455    unsafe impl fidl::encoding::TypeMarker for DeviceRouteUnregisterExternalRouteRequest {
2456        type Owned = Self;
2457
2458        #[inline(always)]
2459        fn inline_align(_context: fidl::encoding::Context) -> usize {
2460            1
2461        }
2462
2463        #[inline(always)]
2464        fn inline_size(_context: fidl::encoding::Context) -> usize {
2465            17
2466        }
2467    }
2468
2469    unsafe impl<D: fidl::encoding::ResourceDialect>
2470        fidl::encoding::Encode<DeviceRouteUnregisterExternalRouteRequest, D>
2471        for &DeviceRouteUnregisterExternalRouteRequest
2472    {
2473        #[inline]
2474        unsafe fn encode(
2475            self,
2476            encoder: &mut fidl::encoding::Encoder<'_, D>,
2477            offset: usize,
2478            _depth: fidl::encoding::Depth,
2479        ) -> fidl::Result<()> {
2480            encoder.debug_check_bounds::<DeviceRouteUnregisterExternalRouteRequest>(offset);
2481            // Delegate to tuple encoding.
2482            fidl::encoding::Encode::<DeviceRouteUnregisterExternalRouteRequest, D>::encode(
2483                (
2484                    <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow(&self.subnet),
2485                ),
2486                encoder, offset, _depth
2487            )
2488        }
2489    }
2490    unsafe impl<
2491            D: fidl::encoding::ResourceDialect,
2492            T0: fidl::encoding::Encode<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>,
2493        > fidl::encoding::Encode<DeviceRouteUnregisterExternalRouteRequest, D> for (T0,)
2494    {
2495        #[inline]
2496        unsafe fn encode(
2497            self,
2498            encoder: &mut fidl::encoding::Encoder<'_, D>,
2499            offset: usize,
2500            depth: fidl::encoding::Depth,
2501        ) -> fidl::Result<()> {
2502            encoder.debug_check_bounds::<DeviceRouteUnregisterExternalRouteRequest>(offset);
2503            // Zero out padding regions. There's no need to apply masks
2504            // because the unmasked parts will be overwritten by fields.
2505            // Write the fields.
2506            self.0.encode(encoder, offset + 0, depth)?;
2507            Ok(())
2508        }
2509    }
2510
2511    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2512        for DeviceRouteUnregisterExternalRouteRequest
2513    {
2514        #[inline(always)]
2515        fn new_empty() -> Self {
2516            Self { subnet: fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D) }
2517        }
2518
2519        #[inline]
2520        unsafe fn decode(
2521            &mut self,
2522            decoder: &mut fidl::encoding::Decoder<'_, D>,
2523            offset: usize,
2524            _depth: fidl::encoding::Depth,
2525        ) -> fidl::Result<()> {
2526            decoder.debug_check_bounds::<Self>(offset);
2527            // Verify that padding bytes are zero.
2528            fidl::decode!(
2529                fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
2530                D,
2531                &mut self.subnet,
2532                decoder,
2533                offset + 0,
2534                _depth
2535            )?;
2536            Ok(())
2537        }
2538    }
2539
2540    impl fidl::encoding::ValueTypeMarker for DeviceRouteUnregisterOnMeshPrefixRequest {
2541        type Borrowed<'a> = &'a Self;
2542        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2543            value
2544        }
2545    }
2546
2547    unsafe impl fidl::encoding::TypeMarker for DeviceRouteUnregisterOnMeshPrefixRequest {
2548        type Owned = Self;
2549
2550        #[inline(always)]
2551        fn inline_align(_context: fidl::encoding::Context) -> usize {
2552            1
2553        }
2554
2555        #[inline(always)]
2556        fn inline_size(_context: fidl::encoding::Context) -> usize {
2557            17
2558        }
2559    }
2560
2561    unsafe impl<D: fidl::encoding::ResourceDialect>
2562        fidl::encoding::Encode<DeviceRouteUnregisterOnMeshPrefixRequest, D>
2563        for &DeviceRouteUnregisterOnMeshPrefixRequest
2564    {
2565        #[inline]
2566        unsafe fn encode(
2567            self,
2568            encoder: &mut fidl::encoding::Encoder<'_, D>,
2569            offset: usize,
2570            _depth: fidl::encoding::Depth,
2571        ) -> fidl::Result<()> {
2572            encoder.debug_check_bounds::<DeviceRouteUnregisterOnMeshPrefixRequest>(offset);
2573            // Delegate to tuple encoding.
2574            fidl::encoding::Encode::<DeviceRouteUnregisterOnMeshPrefixRequest, D>::encode(
2575                (
2576                    <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow(&self.subnet),
2577                ),
2578                encoder, offset, _depth
2579            )
2580        }
2581    }
2582    unsafe impl<
2583            D: fidl::encoding::ResourceDialect,
2584            T0: fidl::encoding::Encode<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>,
2585        > fidl::encoding::Encode<DeviceRouteUnregisterOnMeshPrefixRequest, D> for (T0,)
2586    {
2587        #[inline]
2588        unsafe fn encode(
2589            self,
2590            encoder: &mut fidl::encoding::Encoder<'_, D>,
2591            offset: usize,
2592            depth: fidl::encoding::Depth,
2593        ) -> fidl::Result<()> {
2594            encoder.debug_check_bounds::<DeviceRouteUnregisterOnMeshPrefixRequest>(offset);
2595            // Zero out padding regions. There's no need to apply masks
2596            // because the unmasked parts will be overwritten by fields.
2597            // Write the fields.
2598            self.0.encode(encoder, offset + 0, depth)?;
2599            Ok(())
2600        }
2601    }
2602
2603    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2604        for DeviceRouteUnregisterOnMeshPrefixRequest
2605    {
2606        #[inline(always)]
2607        fn new_empty() -> Self {
2608            Self { subnet: fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D) }
2609        }
2610
2611        #[inline]
2612        unsafe fn decode(
2613            &mut self,
2614            decoder: &mut fidl::encoding::Decoder<'_, D>,
2615            offset: usize,
2616            _depth: fidl::encoding::Depth,
2617        ) -> fidl::Result<()> {
2618            decoder.debug_check_bounds::<Self>(offset);
2619            // Verify that padding bytes are zero.
2620            fidl::decode!(
2621                fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
2622                D,
2623                &mut self.subnet,
2624                decoder,
2625                offset + 0,
2626                _depth
2627            )?;
2628            Ok(())
2629        }
2630    }
2631
2632    impl fidl::encoding::ValueTypeMarker for LegacyJoiningMakeJoinableRequest {
2633        type Borrowed<'a> = &'a Self;
2634        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2635            value
2636        }
2637    }
2638
2639    unsafe impl fidl::encoding::TypeMarker for LegacyJoiningMakeJoinableRequest {
2640        type Owned = Self;
2641
2642        #[inline(always)]
2643        fn inline_align(_context: fidl::encoding::Context) -> usize {
2644            8
2645        }
2646
2647        #[inline(always)]
2648        fn inline_size(_context: fidl::encoding::Context) -> usize {
2649            16
2650        }
2651    }
2652
2653    unsafe impl<D: fidl::encoding::ResourceDialect>
2654        fidl::encoding::Encode<LegacyJoiningMakeJoinableRequest, D>
2655        for &LegacyJoiningMakeJoinableRequest
2656    {
2657        #[inline]
2658        unsafe fn encode(
2659            self,
2660            encoder: &mut fidl::encoding::Encoder<'_, D>,
2661            offset: usize,
2662            _depth: fidl::encoding::Depth,
2663        ) -> fidl::Result<()> {
2664            encoder.debug_check_bounds::<LegacyJoiningMakeJoinableRequest>(offset);
2665            unsafe {
2666                // Copy the object into the buffer.
2667                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2668                (buf_ptr as *mut LegacyJoiningMakeJoinableRequest)
2669                    .write_unaligned((self as *const LegacyJoiningMakeJoinableRequest).read());
2670                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2671                // done second because the memcpy will write garbage to these bytes.
2672                let padding_ptr = buf_ptr.offset(8) as *mut u64;
2673                let padding_mask = 0xffffffffffff0000u64;
2674                padding_ptr.write_unaligned(padding_ptr.read_unaligned() & !padding_mask);
2675            }
2676            Ok(())
2677        }
2678    }
2679    unsafe impl<
2680            D: fidl::encoding::ResourceDialect,
2681            T0: fidl::encoding::Encode<i64, D>,
2682            T1: fidl::encoding::Encode<u16, D>,
2683        > fidl::encoding::Encode<LegacyJoiningMakeJoinableRequest, D> for (T0, T1)
2684    {
2685        #[inline]
2686        unsafe fn encode(
2687            self,
2688            encoder: &mut fidl::encoding::Encoder<'_, D>,
2689            offset: usize,
2690            depth: fidl::encoding::Depth,
2691        ) -> fidl::Result<()> {
2692            encoder.debug_check_bounds::<LegacyJoiningMakeJoinableRequest>(offset);
2693            // Zero out padding regions. There's no need to apply masks
2694            // because the unmasked parts will be overwritten by fields.
2695            unsafe {
2696                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
2697                (ptr as *mut u64).write_unaligned(0);
2698            }
2699            // Write the fields.
2700            self.0.encode(encoder, offset + 0, depth)?;
2701            self.1.encode(encoder, offset + 8, depth)?;
2702            Ok(())
2703        }
2704    }
2705
2706    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2707        for LegacyJoiningMakeJoinableRequest
2708    {
2709        #[inline(always)]
2710        fn new_empty() -> Self {
2711            Self { duration: fidl::new_empty!(i64, D), port: fidl::new_empty!(u16, D) }
2712        }
2713
2714        #[inline]
2715        unsafe fn decode(
2716            &mut self,
2717            decoder: &mut fidl::encoding::Decoder<'_, D>,
2718            offset: usize,
2719            _depth: fidl::encoding::Depth,
2720        ) -> fidl::Result<()> {
2721            decoder.debug_check_bounds::<Self>(offset);
2722            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2723            // Verify that padding bytes are zero.
2724            let ptr = unsafe { buf_ptr.offset(8) };
2725            let padval = unsafe { (ptr as *const u64).read_unaligned() };
2726            let mask = 0xffffffffffff0000u64;
2727            let maskedval = padval & mask;
2728            if maskedval != 0 {
2729                return Err(fidl::Error::NonZeroPadding {
2730                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
2731                });
2732            }
2733            // Copy from the buffer into the object.
2734            unsafe {
2735                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 16);
2736            }
2737            Ok(())
2738        }
2739    }
2740
2741    impl fidl::encoding::ValueTypeMarker for ProvisioningMonitorWatchProgressResponse {
2742        type Borrowed<'a> = &'a Self;
2743        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2744            value
2745        }
2746    }
2747
2748    unsafe impl fidl::encoding::TypeMarker for ProvisioningMonitorWatchProgressResponse {
2749        type Owned = Self;
2750
2751        #[inline(always)]
2752        fn inline_align(_context: fidl::encoding::Context) -> usize {
2753            8
2754        }
2755
2756        #[inline(always)]
2757        fn inline_size(_context: fidl::encoding::Context) -> usize {
2758            16
2759        }
2760    }
2761
2762    unsafe impl<D: fidl::encoding::ResourceDialect>
2763        fidl::encoding::Encode<ProvisioningMonitorWatchProgressResponse, D>
2764        for &ProvisioningMonitorWatchProgressResponse
2765    {
2766        #[inline]
2767        unsafe fn encode(
2768            self,
2769            encoder: &mut fidl::encoding::Encoder<'_, D>,
2770            offset: usize,
2771            _depth: fidl::encoding::Depth,
2772        ) -> fidl::Result<()> {
2773            encoder.debug_check_bounds::<ProvisioningMonitorWatchProgressResponse>(offset);
2774            // Delegate to tuple encoding.
2775            fidl::encoding::Encode::<ProvisioningMonitorWatchProgressResponse, D>::encode(
2776                (<ProvisioningProgress as fidl::encoding::ValueTypeMarker>::borrow(&self.progress),),
2777                encoder,
2778                offset,
2779                _depth,
2780            )
2781        }
2782    }
2783    unsafe impl<
2784            D: fidl::encoding::ResourceDialect,
2785            T0: fidl::encoding::Encode<ProvisioningProgress, D>,
2786        > fidl::encoding::Encode<ProvisioningMonitorWatchProgressResponse, D> for (T0,)
2787    {
2788        #[inline]
2789        unsafe fn encode(
2790            self,
2791            encoder: &mut fidl::encoding::Encoder<'_, D>,
2792            offset: usize,
2793            depth: fidl::encoding::Depth,
2794        ) -> fidl::Result<()> {
2795            encoder.debug_check_bounds::<ProvisioningMonitorWatchProgressResponse>(offset);
2796            // Zero out padding regions. There's no need to apply masks
2797            // because the unmasked parts will be overwritten by fields.
2798            // Write the fields.
2799            self.0.encode(encoder, offset + 0, depth)?;
2800            Ok(())
2801        }
2802    }
2803
2804    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2805        for ProvisioningMonitorWatchProgressResponse
2806    {
2807        #[inline(always)]
2808        fn new_empty() -> Self {
2809            Self { progress: fidl::new_empty!(ProvisioningProgress, D) }
2810        }
2811
2812        #[inline]
2813        unsafe fn decode(
2814            &mut self,
2815            decoder: &mut fidl::encoding::Decoder<'_, D>,
2816            offset: usize,
2817            _depth: fidl::encoding::Depth,
2818        ) -> fidl::Result<()> {
2819            decoder.debug_check_bounds::<Self>(offset);
2820            // Verify that padding bytes are zero.
2821            fidl::decode!(
2822                ProvisioningProgress,
2823                D,
2824                &mut self.progress,
2825                decoder,
2826                offset + 0,
2827                _depth
2828            )?;
2829            Ok(())
2830        }
2831    }
2832
2833    impl fidl::encoding::ValueTypeMarker for TelemetryProviderGetTelemetryResponse {
2834        type Borrowed<'a> = &'a Self;
2835        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2836            value
2837        }
2838    }
2839
2840    unsafe impl fidl::encoding::TypeMarker for TelemetryProviderGetTelemetryResponse {
2841        type Owned = Self;
2842
2843        #[inline(always)]
2844        fn inline_align(_context: fidl::encoding::Context) -> usize {
2845            8
2846        }
2847
2848        #[inline(always)]
2849        fn inline_size(_context: fidl::encoding::Context) -> usize {
2850            16
2851        }
2852    }
2853
2854    unsafe impl<D: fidl::encoding::ResourceDialect>
2855        fidl::encoding::Encode<TelemetryProviderGetTelemetryResponse, D>
2856        for &TelemetryProviderGetTelemetryResponse
2857    {
2858        #[inline]
2859        unsafe fn encode(
2860            self,
2861            encoder: &mut fidl::encoding::Encoder<'_, D>,
2862            offset: usize,
2863            _depth: fidl::encoding::Depth,
2864        ) -> fidl::Result<()> {
2865            encoder.debug_check_bounds::<TelemetryProviderGetTelemetryResponse>(offset);
2866            // Delegate to tuple encoding.
2867            fidl::encoding::Encode::<TelemetryProviderGetTelemetryResponse, D>::encode(
2868                (<Telemetry as fidl::encoding::ValueTypeMarker>::borrow(&self.telemetry),),
2869                encoder,
2870                offset,
2871                _depth,
2872            )
2873        }
2874    }
2875    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Telemetry, D>>
2876        fidl::encoding::Encode<TelemetryProviderGetTelemetryResponse, D> for (T0,)
2877    {
2878        #[inline]
2879        unsafe fn encode(
2880            self,
2881            encoder: &mut fidl::encoding::Encoder<'_, D>,
2882            offset: usize,
2883            depth: fidl::encoding::Depth,
2884        ) -> fidl::Result<()> {
2885            encoder.debug_check_bounds::<TelemetryProviderGetTelemetryResponse>(offset);
2886            // Zero out padding regions. There's no need to apply masks
2887            // because the unmasked parts will be overwritten by fields.
2888            // Write the fields.
2889            self.0.encode(encoder, offset + 0, depth)?;
2890            Ok(())
2891        }
2892    }
2893
2894    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2895        for TelemetryProviderGetTelemetryResponse
2896    {
2897        #[inline(always)]
2898        fn new_empty() -> Self {
2899            Self { telemetry: fidl::new_empty!(Telemetry, D) }
2900        }
2901
2902        #[inline]
2903        unsafe fn decode(
2904            &mut self,
2905            decoder: &mut fidl::encoding::Decoder<'_, D>,
2906            offset: usize,
2907            _depth: fidl::encoding::Depth,
2908        ) -> fidl::Result<()> {
2909            decoder.debug_check_bounds::<Self>(offset);
2910            // Verify that padding bytes are zero.
2911            fidl::decode!(Telemetry, D, &mut self.telemetry, decoder, offset + 0, _depth)?;
2912            Ok(())
2913        }
2914    }
2915
2916    impl BeaconInfo {
2917        #[inline(always)]
2918        fn max_ordinal_present(&self) -> u64 {
2919            if let Some(_) = self.lqi {
2920                return 4;
2921            }
2922            if let Some(_) = self.rssi {
2923                return 3;
2924            }
2925            if let Some(_) = self.identity {
2926                return 2;
2927            }
2928            if let Some(_) = self.address {
2929                return 1;
2930            }
2931            0
2932        }
2933    }
2934
2935    impl fidl::encoding::ValueTypeMarker for BeaconInfo {
2936        type Borrowed<'a> = &'a Self;
2937        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2938            value
2939        }
2940    }
2941
2942    unsafe impl fidl::encoding::TypeMarker for BeaconInfo {
2943        type Owned = Self;
2944
2945        #[inline(always)]
2946        fn inline_align(_context: fidl::encoding::Context) -> usize {
2947            8
2948        }
2949
2950        #[inline(always)]
2951        fn inline_size(_context: fidl::encoding::Context) -> usize {
2952            16
2953        }
2954    }
2955
2956    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BeaconInfo, D>
2957        for &BeaconInfo
2958    {
2959        unsafe fn encode(
2960            self,
2961            encoder: &mut fidl::encoding::Encoder<'_, D>,
2962            offset: usize,
2963            mut depth: fidl::encoding::Depth,
2964        ) -> fidl::Result<()> {
2965            encoder.debug_check_bounds::<BeaconInfo>(offset);
2966            // Vector header
2967            let max_ordinal: u64 = self.max_ordinal_present();
2968            encoder.write_num(max_ordinal, offset);
2969            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2970            // Calling encoder.out_of_line_offset(0) is not allowed.
2971            if max_ordinal == 0 {
2972                return Ok(());
2973            }
2974            depth.increment()?;
2975            let envelope_size = 8;
2976            let bytes_len = max_ordinal as usize * envelope_size;
2977            #[allow(unused_variables)]
2978            let offset = encoder.out_of_line_offset(bytes_len);
2979            let mut _prev_end_offset: usize = 0;
2980            if 1 > max_ordinal {
2981                return Ok(());
2982            }
2983
2984            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2985            // are envelope_size bytes.
2986            let cur_offset: usize = (1 - 1) * envelope_size;
2987
2988            // Zero reserved fields.
2989            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2990
2991            // Safety:
2992            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2993            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2994            //   envelope_size bytes, there is always sufficient room.
2995            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_lowpan__common::MacAddress, D>(
2996            self.address.as_ref().map(<fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
2997            encoder, offset + cur_offset, depth
2998        )?;
2999
3000            _prev_end_offset = cur_offset + envelope_size;
3001            if 2 > max_ordinal {
3002                return Ok(());
3003            }
3004
3005            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3006            // are envelope_size bytes.
3007            let cur_offset: usize = (2 - 1) * envelope_size;
3008
3009            // Zero reserved fields.
3010            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3011
3012            // Safety:
3013            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3014            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3015            //   envelope_size bytes, there is always sufficient room.
3016            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_lowpan_device__common::Identity, D>(
3017            self.identity.as_ref().map(<fidl_fuchsia_lowpan_device__common::Identity as fidl::encoding::ValueTypeMarker>::borrow),
3018            encoder, offset + cur_offset, depth
3019        )?;
3020
3021            _prev_end_offset = cur_offset + envelope_size;
3022            if 3 > max_ordinal {
3023                return Ok(());
3024            }
3025
3026            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3027            // are envelope_size bytes.
3028            let cur_offset: usize = (3 - 1) * envelope_size;
3029
3030            // Zero reserved fields.
3031            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3032
3033            // Safety:
3034            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3035            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3036            //   envelope_size bytes, there is always sufficient room.
3037            fidl::encoding::encode_in_envelope_optional::<i8, D>(
3038                self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
3039                encoder,
3040                offset + cur_offset,
3041                depth,
3042            )?;
3043
3044            _prev_end_offset = cur_offset + envelope_size;
3045            if 4 > max_ordinal {
3046                return Ok(());
3047            }
3048
3049            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3050            // are envelope_size bytes.
3051            let cur_offset: usize = (4 - 1) * envelope_size;
3052
3053            // Zero reserved fields.
3054            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3055
3056            // Safety:
3057            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3058            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3059            //   envelope_size bytes, there is always sufficient room.
3060            fidl::encoding::encode_in_envelope_optional::<u8, D>(
3061                self.lqi.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
3062                encoder,
3063                offset + cur_offset,
3064                depth,
3065            )?;
3066
3067            _prev_end_offset = cur_offset + envelope_size;
3068
3069            Ok(())
3070        }
3071    }
3072
3073    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BeaconInfo {
3074        #[inline(always)]
3075        fn new_empty() -> Self {
3076            Self::default()
3077        }
3078
3079        unsafe fn decode(
3080            &mut self,
3081            decoder: &mut fidl::encoding::Decoder<'_, D>,
3082            offset: usize,
3083            mut depth: fidl::encoding::Depth,
3084        ) -> fidl::Result<()> {
3085            decoder.debug_check_bounds::<Self>(offset);
3086            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3087                None => return Err(fidl::Error::NotNullable),
3088                Some(len) => len,
3089            };
3090            // Calling decoder.out_of_line_offset(0) is not allowed.
3091            if len == 0 {
3092                return Ok(());
3093            };
3094            depth.increment()?;
3095            let envelope_size = 8;
3096            let bytes_len = len * envelope_size;
3097            let offset = decoder.out_of_line_offset(bytes_len)?;
3098            // Decode the envelope for each type.
3099            let mut _next_ordinal_to_read = 0;
3100            let mut next_offset = offset;
3101            let end_offset = offset + bytes_len;
3102            _next_ordinal_to_read += 1;
3103            if next_offset >= end_offset {
3104                return Ok(());
3105            }
3106
3107            // Decode unknown envelopes for gaps in ordinals.
3108            while _next_ordinal_to_read < 1 {
3109                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3110                _next_ordinal_to_read += 1;
3111                next_offset += envelope_size;
3112            }
3113
3114            let next_out_of_line = decoder.next_out_of_line();
3115            let handles_before = decoder.remaining_handles();
3116            if let Some((inlined, num_bytes, num_handles)) =
3117                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3118            {
3119                let member_inline_size = <fidl_fuchsia_lowpan__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3120                if inlined != (member_inline_size <= 4) {
3121                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3122                }
3123                let inner_offset;
3124                let mut inner_depth = depth.clone();
3125                if inlined {
3126                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3127                    inner_offset = next_offset;
3128                } else {
3129                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3130                    inner_depth.increment()?;
3131                }
3132                let val_ref = self.address.get_or_insert_with(|| {
3133                    fidl::new_empty!(fidl_fuchsia_lowpan__common::MacAddress, D)
3134                });
3135                fidl::decode!(
3136                    fidl_fuchsia_lowpan__common::MacAddress,
3137                    D,
3138                    val_ref,
3139                    decoder,
3140                    inner_offset,
3141                    inner_depth
3142                )?;
3143                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3144                {
3145                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3146                }
3147                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3148                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3149                }
3150            }
3151
3152            next_offset += envelope_size;
3153            _next_ordinal_to_read += 1;
3154            if next_offset >= end_offset {
3155                return Ok(());
3156            }
3157
3158            // Decode unknown envelopes for gaps in ordinals.
3159            while _next_ordinal_to_read < 2 {
3160                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3161                _next_ordinal_to_read += 1;
3162                next_offset += envelope_size;
3163            }
3164
3165            let next_out_of_line = decoder.next_out_of_line();
3166            let handles_before = decoder.remaining_handles();
3167            if let Some((inlined, num_bytes, num_handles)) =
3168                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3169            {
3170                let member_inline_size = <fidl_fuchsia_lowpan_device__common::Identity as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3171                if inlined != (member_inline_size <= 4) {
3172                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3173                }
3174                let inner_offset;
3175                let mut inner_depth = depth.clone();
3176                if inlined {
3177                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3178                    inner_offset = next_offset;
3179                } else {
3180                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3181                    inner_depth.increment()?;
3182                }
3183                let val_ref = self.identity.get_or_insert_with(|| {
3184                    fidl::new_empty!(fidl_fuchsia_lowpan_device__common::Identity, D)
3185                });
3186                fidl::decode!(
3187                    fidl_fuchsia_lowpan_device__common::Identity,
3188                    D,
3189                    val_ref,
3190                    decoder,
3191                    inner_offset,
3192                    inner_depth
3193                )?;
3194                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3195                {
3196                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3197                }
3198                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3199                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3200                }
3201            }
3202
3203            next_offset += envelope_size;
3204            _next_ordinal_to_read += 1;
3205            if next_offset >= end_offset {
3206                return Ok(());
3207            }
3208
3209            // Decode unknown envelopes for gaps in ordinals.
3210            while _next_ordinal_to_read < 3 {
3211                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3212                _next_ordinal_to_read += 1;
3213                next_offset += envelope_size;
3214            }
3215
3216            let next_out_of_line = decoder.next_out_of_line();
3217            let handles_before = decoder.remaining_handles();
3218            if let Some((inlined, num_bytes, num_handles)) =
3219                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3220            {
3221                let member_inline_size =
3222                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3223                if inlined != (member_inline_size <= 4) {
3224                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3225                }
3226                let inner_offset;
3227                let mut inner_depth = depth.clone();
3228                if inlined {
3229                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3230                    inner_offset = next_offset;
3231                } else {
3232                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3233                    inner_depth.increment()?;
3234                }
3235                let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
3236                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
3237                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3238                {
3239                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3240                }
3241                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3242                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3243                }
3244            }
3245
3246            next_offset += envelope_size;
3247            _next_ordinal_to_read += 1;
3248            if next_offset >= end_offset {
3249                return Ok(());
3250            }
3251
3252            // Decode unknown envelopes for gaps in ordinals.
3253            while _next_ordinal_to_read < 4 {
3254                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3255                _next_ordinal_to_read += 1;
3256                next_offset += envelope_size;
3257            }
3258
3259            let next_out_of_line = decoder.next_out_of_line();
3260            let handles_before = decoder.remaining_handles();
3261            if let Some((inlined, num_bytes, num_handles)) =
3262                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3263            {
3264                let member_inline_size =
3265                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3266                if inlined != (member_inline_size <= 4) {
3267                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3268                }
3269                let inner_offset;
3270                let mut inner_depth = depth.clone();
3271                if inlined {
3272                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3273                    inner_offset = next_offset;
3274                } else {
3275                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3276                    inner_depth.increment()?;
3277                }
3278                let val_ref = self.lqi.get_or_insert_with(|| fidl::new_empty!(u8, D));
3279                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
3280                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3281                {
3282                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3283                }
3284                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3285                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3286                }
3287            }
3288
3289            next_offset += envelope_size;
3290
3291            // Decode the remaining unknown envelopes.
3292            while next_offset < end_offset {
3293                _next_ordinal_to_read += 1;
3294                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3295                next_offset += envelope_size;
3296            }
3297
3298            Ok(())
3299        }
3300    }
3301
3302    impl BorderRoutingCounters {
3303        #[inline(always)]
3304        fn max_ordinal_present(&self) -> u64 {
3305            if let Some(_) = self.outbound_internet_bytes {
3306                return 18;
3307            }
3308            if let Some(_) = self.outbound_internet_packets {
3309                return 17;
3310            }
3311            if let Some(_) = self.inbound_internet_bytes {
3312                return 16;
3313            }
3314            if let Some(_) = self.inbound_internet_packets {
3315                return 15;
3316            }
3317            if let Some(_) = self.rs_tx_failure {
3318                return 14;
3319            }
3320            if let Some(_) = self.rs_tx_success {
3321                return 13;
3322            }
3323            if let Some(_) = self.rs_rx {
3324                return 12;
3325            }
3326            if let Some(_) = self.ra_tx_failure {
3327                return 11;
3328            }
3329            if let Some(_) = self.ra_tx_success {
3330                return 10;
3331            }
3332            if let Some(_) = self.ra_rx {
3333                return 9;
3334            }
3335            if let Some(_) = self.outbound_multicast_bytes {
3336                return 8;
3337            }
3338            if let Some(_) = self.outbound_multicast_packets {
3339                return 7;
3340            }
3341            if let Some(_) = self.outbound_unicast_bytes {
3342                return 6;
3343            }
3344            if let Some(_) = self.outbound_unicast_packets {
3345                return 5;
3346            }
3347            if let Some(_) = self.inbound_multicast_bytes {
3348                return 4;
3349            }
3350            if let Some(_) = self.inbound_multicast_packets {
3351                return 3;
3352            }
3353            if let Some(_) = self.inbound_unicast_bytes {
3354                return 2;
3355            }
3356            if let Some(_) = self.inbound_unicast_packets {
3357                return 1;
3358            }
3359            0
3360        }
3361    }
3362
3363    impl fidl::encoding::ValueTypeMarker for BorderRoutingCounters {
3364        type Borrowed<'a> = &'a Self;
3365        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3366            value
3367        }
3368    }
3369
3370    unsafe impl fidl::encoding::TypeMarker for BorderRoutingCounters {
3371        type Owned = Self;
3372
3373        #[inline(always)]
3374        fn inline_align(_context: fidl::encoding::Context) -> usize {
3375            8
3376        }
3377
3378        #[inline(always)]
3379        fn inline_size(_context: fidl::encoding::Context) -> usize {
3380            16
3381        }
3382    }
3383
3384    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BorderRoutingCounters, D>
3385        for &BorderRoutingCounters
3386    {
3387        unsafe fn encode(
3388            self,
3389            encoder: &mut fidl::encoding::Encoder<'_, D>,
3390            offset: usize,
3391            mut depth: fidl::encoding::Depth,
3392        ) -> fidl::Result<()> {
3393            encoder.debug_check_bounds::<BorderRoutingCounters>(offset);
3394            // Vector header
3395            let max_ordinal: u64 = self.max_ordinal_present();
3396            encoder.write_num(max_ordinal, offset);
3397            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3398            // Calling encoder.out_of_line_offset(0) is not allowed.
3399            if max_ordinal == 0 {
3400                return Ok(());
3401            }
3402            depth.increment()?;
3403            let envelope_size = 8;
3404            let bytes_len = max_ordinal as usize * envelope_size;
3405            #[allow(unused_variables)]
3406            let offset = encoder.out_of_line_offset(bytes_len);
3407            let mut _prev_end_offset: usize = 0;
3408            if 1 > max_ordinal {
3409                return Ok(());
3410            }
3411
3412            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3413            // are envelope_size bytes.
3414            let cur_offset: usize = (1 - 1) * envelope_size;
3415
3416            // Zero reserved fields.
3417            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3418
3419            // Safety:
3420            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3421            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3422            //   envelope_size bytes, there is always sufficient room.
3423            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3424                self.inbound_unicast_packets
3425                    .as_ref()
3426                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3427                encoder,
3428                offset + cur_offset,
3429                depth,
3430            )?;
3431
3432            _prev_end_offset = cur_offset + envelope_size;
3433            if 2 > max_ordinal {
3434                return Ok(());
3435            }
3436
3437            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3438            // are envelope_size bytes.
3439            let cur_offset: usize = (2 - 1) * envelope_size;
3440
3441            // Zero reserved fields.
3442            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3443
3444            // Safety:
3445            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3446            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3447            //   envelope_size bytes, there is always sufficient room.
3448            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3449                self.inbound_unicast_bytes
3450                    .as_ref()
3451                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3452                encoder,
3453                offset + cur_offset,
3454                depth,
3455            )?;
3456
3457            _prev_end_offset = cur_offset + envelope_size;
3458            if 3 > max_ordinal {
3459                return Ok(());
3460            }
3461
3462            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3463            // are envelope_size bytes.
3464            let cur_offset: usize = (3 - 1) * envelope_size;
3465
3466            // Zero reserved fields.
3467            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3468
3469            // Safety:
3470            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3471            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3472            //   envelope_size bytes, there is always sufficient room.
3473            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3474                self.inbound_multicast_packets
3475                    .as_ref()
3476                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3477                encoder,
3478                offset + cur_offset,
3479                depth,
3480            )?;
3481
3482            _prev_end_offset = cur_offset + envelope_size;
3483            if 4 > max_ordinal {
3484                return Ok(());
3485            }
3486
3487            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3488            // are envelope_size bytes.
3489            let cur_offset: usize = (4 - 1) * envelope_size;
3490
3491            // Zero reserved fields.
3492            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3493
3494            // Safety:
3495            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3496            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3497            //   envelope_size bytes, there is always sufficient room.
3498            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3499                self.inbound_multicast_bytes
3500                    .as_ref()
3501                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3502                encoder,
3503                offset + cur_offset,
3504                depth,
3505            )?;
3506
3507            _prev_end_offset = cur_offset + envelope_size;
3508            if 5 > max_ordinal {
3509                return Ok(());
3510            }
3511
3512            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3513            // are envelope_size bytes.
3514            let cur_offset: usize = (5 - 1) * envelope_size;
3515
3516            // Zero reserved fields.
3517            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3518
3519            // Safety:
3520            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3521            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3522            //   envelope_size bytes, there is always sufficient room.
3523            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3524                self.outbound_unicast_packets
3525                    .as_ref()
3526                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3527                encoder,
3528                offset + cur_offset,
3529                depth,
3530            )?;
3531
3532            _prev_end_offset = cur_offset + envelope_size;
3533            if 6 > max_ordinal {
3534                return Ok(());
3535            }
3536
3537            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3538            // are envelope_size bytes.
3539            let cur_offset: usize = (6 - 1) * envelope_size;
3540
3541            // Zero reserved fields.
3542            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3543
3544            // Safety:
3545            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3546            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3547            //   envelope_size bytes, there is always sufficient room.
3548            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3549                self.outbound_unicast_bytes
3550                    .as_ref()
3551                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3552                encoder,
3553                offset + cur_offset,
3554                depth,
3555            )?;
3556
3557            _prev_end_offset = cur_offset + envelope_size;
3558            if 7 > max_ordinal {
3559                return Ok(());
3560            }
3561
3562            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3563            // are envelope_size bytes.
3564            let cur_offset: usize = (7 - 1) * envelope_size;
3565
3566            // Zero reserved fields.
3567            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3568
3569            // Safety:
3570            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3571            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3572            //   envelope_size bytes, there is always sufficient room.
3573            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3574                self.outbound_multicast_packets
3575                    .as_ref()
3576                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3577                encoder,
3578                offset + cur_offset,
3579                depth,
3580            )?;
3581
3582            _prev_end_offset = cur_offset + envelope_size;
3583            if 8 > max_ordinal {
3584                return Ok(());
3585            }
3586
3587            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3588            // are envelope_size bytes.
3589            let cur_offset: usize = (8 - 1) * envelope_size;
3590
3591            // Zero reserved fields.
3592            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3593
3594            // Safety:
3595            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3596            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3597            //   envelope_size bytes, there is always sufficient room.
3598            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3599                self.outbound_multicast_bytes
3600                    .as_ref()
3601                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3602                encoder,
3603                offset + cur_offset,
3604                depth,
3605            )?;
3606
3607            _prev_end_offset = cur_offset + envelope_size;
3608            if 9 > max_ordinal {
3609                return Ok(());
3610            }
3611
3612            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3613            // are envelope_size bytes.
3614            let cur_offset: usize = (9 - 1) * envelope_size;
3615
3616            // Zero reserved fields.
3617            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3618
3619            // Safety:
3620            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3621            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3622            //   envelope_size bytes, there is always sufficient room.
3623            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3624                self.ra_rx.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3625                encoder,
3626                offset + cur_offset,
3627                depth,
3628            )?;
3629
3630            _prev_end_offset = cur_offset + envelope_size;
3631            if 10 > max_ordinal {
3632                return Ok(());
3633            }
3634
3635            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3636            // are envelope_size bytes.
3637            let cur_offset: usize = (10 - 1) * envelope_size;
3638
3639            // Zero reserved fields.
3640            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3641
3642            // Safety:
3643            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3644            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3645            //   envelope_size bytes, there is always sufficient room.
3646            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3647                self.ra_tx_success.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3648                encoder,
3649                offset + cur_offset,
3650                depth,
3651            )?;
3652
3653            _prev_end_offset = cur_offset + envelope_size;
3654            if 11 > max_ordinal {
3655                return Ok(());
3656            }
3657
3658            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3659            // are envelope_size bytes.
3660            let cur_offset: usize = (11 - 1) * envelope_size;
3661
3662            // Zero reserved fields.
3663            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3664
3665            // Safety:
3666            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3667            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3668            //   envelope_size bytes, there is always sufficient room.
3669            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3670                self.ra_tx_failure.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3671                encoder,
3672                offset + cur_offset,
3673                depth,
3674            )?;
3675
3676            _prev_end_offset = cur_offset + envelope_size;
3677            if 12 > max_ordinal {
3678                return Ok(());
3679            }
3680
3681            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3682            // are envelope_size bytes.
3683            let cur_offset: usize = (12 - 1) * envelope_size;
3684
3685            // Zero reserved fields.
3686            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3687
3688            // Safety:
3689            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3690            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3691            //   envelope_size bytes, there is always sufficient room.
3692            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3693                self.rs_rx.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3694                encoder,
3695                offset + cur_offset,
3696                depth,
3697            )?;
3698
3699            _prev_end_offset = cur_offset + envelope_size;
3700            if 13 > max_ordinal {
3701                return Ok(());
3702            }
3703
3704            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3705            // are envelope_size bytes.
3706            let cur_offset: usize = (13 - 1) * envelope_size;
3707
3708            // Zero reserved fields.
3709            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3710
3711            // Safety:
3712            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3713            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3714            //   envelope_size bytes, there is always sufficient room.
3715            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3716                self.rs_tx_success.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3717                encoder,
3718                offset + cur_offset,
3719                depth,
3720            )?;
3721
3722            _prev_end_offset = cur_offset + envelope_size;
3723            if 14 > max_ordinal {
3724                return Ok(());
3725            }
3726
3727            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3728            // are envelope_size bytes.
3729            let cur_offset: usize = (14 - 1) * envelope_size;
3730
3731            // Zero reserved fields.
3732            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3733
3734            // Safety:
3735            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3736            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3737            //   envelope_size bytes, there is always sufficient room.
3738            fidl::encoding::encode_in_envelope_optional::<u32, D>(
3739                self.rs_tx_failure.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
3740                encoder,
3741                offset + cur_offset,
3742                depth,
3743            )?;
3744
3745            _prev_end_offset = cur_offset + envelope_size;
3746            if 15 > max_ordinal {
3747                return Ok(());
3748            }
3749
3750            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3751            // are envelope_size bytes.
3752            let cur_offset: usize = (15 - 1) * envelope_size;
3753
3754            // Zero reserved fields.
3755            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3756
3757            // Safety:
3758            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3759            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3760            //   envelope_size bytes, there is always sufficient room.
3761            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3762                self.inbound_internet_packets
3763                    .as_ref()
3764                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3765                encoder,
3766                offset + cur_offset,
3767                depth,
3768            )?;
3769
3770            _prev_end_offset = cur_offset + envelope_size;
3771            if 16 > max_ordinal {
3772                return Ok(());
3773            }
3774
3775            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3776            // are envelope_size bytes.
3777            let cur_offset: usize = (16 - 1) * envelope_size;
3778
3779            // Zero reserved fields.
3780            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3781
3782            // Safety:
3783            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3784            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3785            //   envelope_size bytes, there is always sufficient room.
3786            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3787                self.inbound_internet_bytes
3788                    .as_ref()
3789                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3790                encoder,
3791                offset + cur_offset,
3792                depth,
3793            )?;
3794
3795            _prev_end_offset = cur_offset + envelope_size;
3796            if 17 > max_ordinal {
3797                return Ok(());
3798            }
3799
3800            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3801            // are envelope_size bytes.
3802            let cur_offset: usize = (17 - 1) * envelope_size;
3803
3804            // Zero reserved fields.
3805            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3806
3807            // Safety:
3808            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3809            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3810            //   envelope_size bytes, there is always sufficient room.
3811            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3812                self.outbound_internet_packets
3813                    .as_ref()
3814                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3815                encoder,
3816                offset + cur_offset,
3817                depth,
3818            )?;
3819
3820            _prev_end_offset = cur_offset + envelope_size;
3821            if 18 > max_ordinal {
3822                return Ok(());
3823            }
3824
3825            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3826            // are envelope_size bytes.
3827            let cur_offset: usize = (18 - 1) * envelope_size;
3828
3829            // Zero reserved fields.
3830            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3831
3832            // Safety:
3833            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3834            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3835            //   envelope_size bytes, there is always sufficient room.
3836            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3837                self.outbound_internet_bytes
3838                    .as_ref()
3839                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3840                encoder,
3841                offset + cur_offset,
3842                depth,
3843            )?;
3844
3845            _prev_end_offset = cur_offset + envelope_size;
3846
3847            Ok(())
3848        }
3849    }
3850
3851    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BorderRoutingCounters {
3852        #[inline(always)]
3853        fn new_empty() -> Self {
3854            Self::default()
3855        }
3856
3857        unsafe fn decode(
3858            &mut self,
3859            decoder: &mut fidl::encoding::Decoder<'_, D>,
3860            offset: usize,
3861            mut depth: fidl::encoding::Depth,
3862        ) -> fidl::Result<()> {
3863            decoder.debug_check_bounds::<Self>(offset);
3864            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3865                None => return Err(fidl::Error::NotNullable),
3866                Some(len) => len,
3867            };
3868            // Calling decoder.out_of_line_offset(0) is not allowed.
3869            if len == 0 {
3870                return Ok(());
3871            };
3872            depth.increment()?;
3873            let envelope_size = 8;
3874            let bytes_len = len * envelope_size;
3875            let offset = decoder.out_of_line_offset(bytes_len)?;
3876            // Decode the envelope for each type.
3877            let mut _next_ordinal_to_read = 0;
3878            let mut next_offset = offset;
3879            let end_offset = offset + bytes_len;
3880            _next_ordinal_to_read += 1;
3881            if next_offset >= end_offset {
3882                return Ok(());
3883            }
3884
3885            // Decode unknown envelopes for gaps in ordinals.
3886            while _next_ordinal_to_read < 1 {
3887                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3888                _next_ordinal_to_read += 1;
3889                next_offset += envelope_size;
3890            }
3891
3892            let next_out_of_line = decoder.next_out_of_line();
3893            let handles_before = decoder.remaining_handles();
3894            if let Some((inlined, num_bytes, num_handles)) =
3895                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3896            {
3897                let member_inline_size =
3898                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3899                if inlined != (member_inline_size <= 4) {
3900                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3901                }
3902                let inner_offset;
3903                let mut inner_depth = depth.clone();
3904                if inlined {
3905                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3906                    inner_offset = next_offset;
3907                } else {
3908                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3909                    inner_depth.increment()?;
3910                }
3911                let val_ref =
3912                    self.inbound_unicast_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
3913                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3914                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3915                {
3916                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3917                }
3918                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3919                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3920                }
3921            }
3922
3923            next_offset += envelope_size;
3924            _next_ordinal_to_read += 1;
3925            if next_offset >= end_offset {
3926                return Ok(());
3927            }
3928
3929            // Decode unknown envelopes for gaps in ordinals.
3930            while _next_ordinal_to_read < 2 {
3931                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3932                _next_ordinal_to_read += 1;
3933                next_offset += envelope_size;
3934            }
3935
3936            let next_out_of_line = decoder.next_out_of_line();
3937            let handles_before = decoder.remaining_handles();
3938            if let Some((inlined, num_bytes, num_handles)) =
3939                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3940            {
3941                let member_inline_size =
3942                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3943                if inlined != (member_inline_size <= 4) {
3944                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3945                }
3946                let inner_offset;
3947                let mut inner_depth = depth.clone();
3948                if inlined {
3949                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3950                    inner_offset = next_offset;
3951                } else {
3952                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3953                    inner_depth.increment()?;
3954                }
3955                let val_ref =
3956                    self.inbound_unicast_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
3957                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3958                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3959                {
3960                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3961                }
3962                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3963                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3964                }
3965            }
3966
3967            next_offset += envelope_size;
3968            _next_ordinal_to_read += 1;
3969            if next_offset >= end_offset {
3970                return Ok(());
3971            }
3972
3973            // Decode unknown envelopes for gaps in ordinals.
3974            while _next_ordinal_to_read < 3 {
3975                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3976                _next_ordinal_to_read += 1;
3977                next_offset += envelope_size;
3978            }
3979
3980            let next_out_of_line = decoder.next_out_of_line();
3981            let handles_before = decoder.remaining_handles();
3982            if let Some((inlined, num_bytes, num_handles)) =
3983                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3984            {
3985                let member_inline_size =
3986                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3987                if inlined != (member_inline_size <= 4) {
3988                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3989                }
3990                let inner_offset;
3991                let mut inner_depth = depth.clone();
3992                if inlined {
3993                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3994                    inner_offset = next_offset;
3995                } else {
3996                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3997                    inner_depth.increment()?;
3998                }
3999                let val_ref =
4000                    self.inbound_multicast_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
4001                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4002                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4003                {
4004                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4005                }
4006                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4007                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4008                }
4009            }
4010
4011            next_offset += envelope_size;
4012            _next_ordinal_to_read += 1;
4013            if next_offset >= end_offset {
4014                return Ok(());
4015            }
4016
4017            // Decode unknown envelopes for gaps in ordinals.
4018            while _next_ordinal_to_read < 4 {
4019                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4020                _next_ordinal_to_read += 1;
4021                next_offset += envelope_size;
4022            }
4023
4024            let next_out_of_line = decoder.next_out_of_line();
4025            let handles_before = decoder.remaining_handles();
4026            if let Some((inlined, num_bytes, num_handles)) =
4027                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4028            {
4029                let member_inline_size =
4030                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4031                if inlined != (member_inline_size <= 4) {
4032                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4033                }
4034                let inner_offset;
4035                let mut inner_depth = depth.clone();
4036                if inlined {
4037                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4038                    inner_offset = next_offset;
4039                } else {
4040                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4041                    inner_depth.increment()?;
4042                }
4043                let val_ref =
4044                    self.inbound_multicast_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4045                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4046                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4047                {
4048                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4049                }
4050                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4051                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4052                }
4053            }
4054
4055            next_offset += envelope_size;
4056            _next_ordinal_to_read += 1;
4057            if next_offset >= end_offset {
4058                return Ok(());
4059            }
4060
4061            // Decode unknown envelopes for gaps in ordinals.
4062            while _next_ordinal_to_read < 5 {
4063                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4064                _next_ordinal_to_read += 1;
4065                next_offset += envelope_size;
4066            }
4067
4068            let next_out_of_line = decoder.next_out_of_line();
4069            let handles_before = decoder.remaining_handles();
4070            if let Some((inlined, num_bytes, num_handles)) =
4071                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4072            {
4073                let member_inline_size =
4074                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4075                if inlined != (member_inline_size <= 4) {
4076                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4077                }
4078                let inner_offset;
4079                let mut inner_depth = depth.clone();
4080                if inlined {
4081                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4082                    inner_offset = next_offset;
4083                } else {
4084                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4085                    inner_depth.increment()?;
4086                }
4087                let val_ref =
4088                    self.outbound_unicast_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
4089                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4090                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4091                {
4092                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4093                }
4094                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4095                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4096                }
4097            }
4098
4099            next_offset += envelope_size;
4100            _next_ordinal_to_read += 1;
4101            if next_offset >= end_offset {
4102                return Ok(());
4103            }
4104
4105            // Decode unknown envelopes for gaps in ordinals.
4106            while _next_ordinal_to_read < 6 {
4107                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4108                _next_ordinal_to_read += 1;
4109                next_offset += envelope_size;
4110            }
4111
4112            let next_out_of_line = decoder.next_out_of_line();
4113            let handles_before = decoder.remaining_handles();
4114            if let Some((inlined, num_bytes, num_handles)) =
4115                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4116            {
4117                let member_inline_size =
4118                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4119                if inlined != (member_inline_size <= 4) {
4120                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4121                }
4122                let inner_offset;
4123                let mut inner_depth = depth.clone();
4124                if inlined {
4125                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4126                    inner_offset = next_offset;
4127                } else {
4128                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4129                    inner_depth.increment()?;
4130                }
4131                let val_ref =
4132                    self.outbound_unicast_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4133                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4134                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4135                {
4136                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4137                }
4138                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4139                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4140                }
4141            }
4142
4143            next_offset += envelope_size;
4144            _next_ordinal_to_read += 1;
4145            if next_offset >= end_offset {
4146                return Ok(());
4147            }
4148
4149            // Decode unknown envelopes for gaps in ordinals.
4150            while _next_ordinal_to_read < 7 {
4151                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4152                _next_ordinal_to_read += 1;
4153                next_offset += envelope_size;
4154            }
4155
4156            let next_out_of_line = decoder.next_out_of_line();
4157            let handles_before = decoder.remaining_handles();
4158            if let Some((inlined, num_bytes, num_handles)) =
4159                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4160            {
4161                let member_inline_size =
4162                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4163                if inlined != (member_inline_size <= 4) {
4164                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4165                }
4166                let inner_offset;
4167                let mut inner_depth = depth.clone();
4168                if inlined {
4169                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4170                    inner_offset = next_offset;
4171                } else {
4172                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4173                    inner_depth.increment()?;
4174                }
4175                let val_ref =
4176                    self.outbound_multicast_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
4177                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4178                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4179                {
4180                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4181                }
4182                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4183                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4184                }
4185            }
4186
4187            next_offset += envelope_size;
4188            _next_ordinal_to_read += 1;
4189            if next_offset >= end_offset {
4190                return Ok(());
4191            }
4192
4193            // Decode unknown envelopes for gaps in ordinals.
4194            while _next_ordinal_to_read < 8 {
4195                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4196                _next_ordinal_to_read += 1;
4197                next_offset += envelope_size;
4198            }
4199
4200            let next_out_of_line = decoder.next_out_of_line();
4201            let handles_before = decoder.remaining_handles();
4202            if let Some((inlined, num_bytes, num_handles)) =
4203                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4204            {
4205                let member_inline_size =
4206                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4207                if inlined != (member_inline_size <= 4) {
4208                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4209                }
4210                let inner_offset;
4211                let mut inner_depth = depth.clone();
4212                if inlined {
4213                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4214                    inner_offset = next_offset;
4215                } else {
4216                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4217                    inner_depth.increment()?;
4218                }
4219                let val_ref =
4220                    self.outbound_multicast_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4221                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4222                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4223                {
4224                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4225                }
4226                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4227                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4228                }
4229            }
4230
4231            next_offset += envelope_size;
4232            _next_ordinal_to_read += 1;
4233            if next_offset >= end_offset {
4234                return Ok(());
4235            }
4236
4237            // Decode unknown envelopes for gaps in ordinals.
4238            while _next_ordinal_to_read < 9 {
4239                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4240                _next_ordinal_to_read += 1;
4241                next_offset += envelope_size;
4242            }
4243
4244            let next_out_of_line = decoder.next_out_of_line();
4245            let handles_before = decoder.remaining_handles();
4246            if let Some((inlined, num_bytes, num_handles)) =
4247                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4248            {
4249                let member_inline_size =
4250                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4251                if inlined != (member_inline_size <= 4) {
4252                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4253                }
4254                let inner_offset;
4255                let mut inner_depth = depth.clone();
4256                if inlined {
4257                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4258                    inner_offset = next_offset;
4259                } else {
4260                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4261                    inner_depth.increment()?;
4262                }
4263                let val_ref = self.ra_rx.get_or_insert_with(|| fidl::new_empty!(u32, D));
4264                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4265                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4266                {
4267                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4268                }
4269                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4270                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4271                }
4272            }
4273
4274            next_offset += envelope_size;
4275            _next_ordinal_to_read += 1;
4276            if next_offset >= end_offset {
4277                return Ok(());
4278            }
4279
4280            // Decode unknown envelopes for gaps in ordinals.
4281            while _next_ordinal_to_read < 10 {
4282                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4283                _next_ordinal_to_read += 1;
4284                next_offset += envelope_size;
4285            }
4286
4287            let next_out_of_line = decoder.next_out_of_line();
4288            let handles_before = decoder.remaining_handles();
4289            if let Some((inlined, num_bytes, num_handles)) =
4290                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4291            {
4292                let member_inline_size =
4293                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4294                if inlined != (member_inline_size <= 4) {
4295                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4296                }
4297                let inner_offset;
4298                let mut inner_depth = depth.clone();
4299                if inlined {
4300                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4301                    inner_offset = next_offset;
4302                } else {
4303                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4304                    inner_depth.increment()?;
4305                }
4306                let val_ref = self.ra_tx_success.get_or_insert_with(|| fidl::new_empty!(u32, D));
4307                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4308                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4309                {
4310                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4311                }
4312                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4313                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4314                }
4315            }
4316
4317            next_offset += envelope_size;
4318            _next_ordinal_to_read += 1;
4319            if next_offset >= end_offset {
4320                return Ok(());
4321            }
4322
4323            // Decode unknown envelopes for gaps in ordinals.
4324            while _next_ordinal_to_read < 11 {
4325                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4326                _next_ordinal_to_read += 1;
4327                next_offset += envelope_size;
4328            }
4329
4330            let next_out_of_line = decoder.next_out_of_line();
4331            let handles_before = decoder.remaining_handles();
4332            if let Some((inlined, num_bytes, num_handles)) =
4333                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4334            {
4335                let member_inline_size =
4336                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4337                if inlined != (member_inline_size <= 4) {
4338                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4339                }
4340                let inner_offset;
4341                let mut inner_depth = depth.clone();
4342                if inlined {
4343                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4344                    inner_offset = next_offset;
4345                } else {
4346                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4347                    inner_depth.increment()?;
4348                }
4349                let val_ref = self.ra_tx_failure.get_or_insert_with(|| fidl::new_empty!(u32, D));
4350                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4351                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4352                {
4353                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4354                }
4355                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4356                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4357                }
4358            }
4359
4360            next_offset += envelope_size;
4361            _next_ordinal_to_read += 1;
4362            if next_offset >= end_offset {
4363                return Ok(());
4364            }
4365
4366            // Decode unknown envelopes for gaps in ordinals.
4367            while _next_ordinal_to_read < 12 {
4368                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4369                _next_ordinal_to_read += 1;
4370                next_offset += envelope_size;
4371            }
4372
4373            let next_out_of_line = decoder.next_out_of_line();
4374            let handles_before = decoder.remaining_handles();
4375            if let Some((inlined, num_bytes, num_handles)) =
4376                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4377            {
4378                let member_inline_size =
4379                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4380                if inlined != (member_inline_size <= 4) {
4381                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4382                }
4383                let inner_offset;
4384                let mut inner_depth = depth.clone();
4385                if inlined {
4386                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4387                    inner_offset = next_offset;
4388                } else {
4389                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4390                    inner_depth.increment()?;
4391                }
4392                let val_ref = self.rs_rx.get_or_insert_with(|| fidl::new_empty!(u32, D));
4393                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4394                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4395                {
4396                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4397                }
4398                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4399                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4400                }
4401            }
4402
4403            next_offset += envelope_size;
4404            _next_ordinal_to_read += 1;
4405            if next_offset >= end_offset {
4406                return Ok(());
4407            }
4408
4409            // Decode unknown envelopes for gaps in ordinals.
4410            while _next_ordinal_to_read < 13 {
4411                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4412                _next_ordinal_to_read += 1;
4413                next_offset += envelope_size;
4414            }
4415
4416            let next_out_of_line = decoder.next_out_of_line();
4417            let handles_before = decoder.remaining_handles();
4418            if let Some((inlined, num_bytes, num_handles)) =
4419                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4420            {
4421                let member_inline_size =
4422                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4423                if inlined != (member_inline_size <= 4) {
4424                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4425                }
4426                let inner_offset;
4427                let mut inner_depth = depth.clone();
4428                if inlined {
4429                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4430                    inner_offset = next_offset;
4431                } else {
4432                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4433                    inner_depth.increment()?;
4434                }
4435                let val_ref = self.rs_tx_success.get_or_insert_with(|| fidl::new_empty!(u32, D));
4436                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4437                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4438                {
4439                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4440                }
4441                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4442                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4443                }
4444            }
4445
4446            next_offset += envelope_size;
4447            _next_ordinal_to_read += 1;
4448            if next_offset >= end_offset {
4449                return Ok(());
4450            }
4451
4452            // Decode unknown envelopes for gaps in ordinals.
4453            while _next_ordinal_to_read < 14 {
4454                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4455                _next_ordinal_to_read += 1;
4456                next_offset += envelope_size;
4457            }
4458
4459            let next_out_of_line = decoder.next_out_of_line();
4460            let handles_before = decoder.remaining_handles();
4461            if let Some((inlined, num_bytes, num_handles)) =
4462                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4463            {
4464                let member_inline_size =
4465                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4466                if inlined != (member_inline_size <= 4) {
4467                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4468                }
4469                let inner_offset;
4470                let mut inner_depth = depth.clone();
4471                if inlined {
4472                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4473                    inner_offset = next_offset;
4474                } else {
4475                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4476                    inner_depth.increment()?;
4477                }
4478                let val_ref = self.rs_tx_failure.get_or_insert_with(|| fidl::new_empty!(u32, D));
4479                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4480                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4481                {
4482                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4483                }
4484                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4485                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4486                }
4487            }
4488
4489            next_offset += envelope_size;
4490            _next_ordinal_to_read += 1;
4491            if next_offset >= end_offset {
4492                return Ok(());
4493            }
4494
4495            // Decode unknown envelopes for gaps in ordinals.
4496            while _next_ordinal_to_read < 15 {
4497                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4498                _next_ordinal_to_read += 1;
4499                next_offset += envelope_size;
4500            }
4501
4502            let next_out_of_line = decoder.next_out_of_line();
4503            let handles_before = decoder.remaining_handles();
4504            if let Some((inlined, num_bytes, num_handles)) =
4505                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4506            {
4507                let member_inline_size =
4508                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4509                if inlined != (member_inline_size <= 4) {
4510                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4511                }
4512                let inner_offset;
4513                let mut inner_depth = depth.clone();
4514                if inlined {
4515                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4516                    inner_offset = next_offset;
4517                } else {
4518                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4519                    inner_depth.increment()?;
4520                }
4521                let val_ref =
4522                    self.inbound_internet_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
4523                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4524                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4525                {
4526                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4527                }
4528                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4529                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4530                }
4531            }
4532
4533            next_offset += envelope_size;
4534            _next_ordinal_to_read += 1;
4535            if next_offset >= end_offset {
4536                return Ok(());
4537            }
4538
4539            // Decode unknown envelopes for gaps in ordinals.
4540            while _next_ordinal_to_read < 16 {
4541                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4542                _next_ordinal_to_read += 1;
4543                next_offset += envelope_size;
4544            }
4545
4546            let next_out_of_line = decoder.next_out_of_line();
4547            let handles_before = decoder.remaining_handles();
4548            if let Some((inlined, num_bytes, num_handles)) =
4549                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4550            {
4551                let member_inline_size =
4552                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4553                if inlined != (member_inline_size <= 4) {
4554                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4555                }
4556                let inner_offset;
4557                let mut inner_depth = depth.clone();
4558                if inlined {
4559                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4560                    inner_offset = next_offset;
4561                } else {
4562                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4563                    inner_depth.increment()?;
4564                }
4565                let val_ref =
4566                    self.inbound_internet_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4567                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4568                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4569                {
4570                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4571                }
4572                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4573                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4574                }
4575            }
4576
4577            next_offset += envelope_size;
4578            _next_ordinal_to_read += 1;
4579            if next_offset >= end_offset {
4580                return Ok(());
4581            }
4582
4583            // Decode unknown envelopes for gaps in ordinals.
4584            while _next_ordinal_to_read < 17 {
4585                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4586                _next_ordinal_to_read += 1;
4587                next_offset += envelope_size;
4588            }
4589
4590            let next_out_of_line = decoder.next_out_of_line();
4591            let handles_before = decoder.remaining_handles();
4592            if let Some((inlined, num_bytes, num_handles)) =
4593                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4594            {
4595                let member_inline_size =
4596                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4597                if inlined != (member_inline_size <= 4) {
4598                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4599                }
4600                let inner_offset;
4601                let mut inner_depth = depth.clone();
4602                if inlined {
4603                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4604                    inner_offset = next_offset;
4605                } else {
4606                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4607                    inner_depth.increment()?;
4608                }
4609                let val_ref =
4610                    self.outbound_internet_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
4611                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4612                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4613                {
4614                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4615                }
4616                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4617                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4618                }
4619            }
4620
4621            next_offset += envelope_size;
4622            _next_ordinal_to_read += 1;
4623            if next_offset >= end_offset {
4624                return Ok(());
4625            }
4626
4627            // Decode unknown envelopes for gaps in ordinals.
4628            while _next_ordinal_to_read < 18 {
4629                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4630                _next_ordinal_to_read += 1;
4631                next_offset += envelope_size;
4632            }
4633
4634            let next_out_of_line = decoder.next_out_of_line();
4635            let handles_before = decoder.remaining_handles();
4636            if let Some((inlined, num_bytes, num_handles)) =
4637                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4638            {
4639                let member_inline_size =
4640                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4641                if inlined != (member_inline_size <= 4) {
4642                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4643                }
4644                let inner_offset;
4645                let mut inner_depth = depth.clone();
4646                if inlined {
4647                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4648                    inner_offset = next_offset;
4649                } else {
4650                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4651                    inner_depth.increment()?;
4652                }
4653                let val_ref =
4654                    self.outbound_internet_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
4655                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
4656                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4657                {
4658                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4659                }
4660                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4661                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4662                }
4663            }
4664
4665            next_offset += envelope_size;
4666
4667            // Decode the remaining unknown envelopes.
4668            while next_offset < end_offset {
4669                _next_ordinal_to_read += 1;
4670                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4671                next_offset += envelope_size;
4672            }
4673
4674            Ok(())
4675        }
4676    }
4677
4678    impl BorderRoutingNat64State {
4679        #[inline(always)]
4680        fn max_ordinal_present(&self) -> u64 {
4681            if let Some(_) = self.translator_state {
4682                return 2;
4683            }
4684            if let Some(_) = self.prefix_manager_state {
4685                return 1;
4686            }
4687            0
4688        }
4689    }
4690
4691    impl fidl::encoding::ValueTypeMarker for BorderRoutingNat64State {
4692        type Borrowed<'a> = &'a Self;
4693        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4694            value
4695        }
4696    }
4697
4698    unsafe impl fidl::encoding::TypeMarker for BorderRoutingNat64State {
4699        type Owned = Self;
4700
4701        #[inline(always)]
4702        fn inline_align(_context: fidl::encoding::Context) -> usize {
4703            8
4704        }
4705
4706        #[inline(always)]
4707        fn inline_size(_context: fidl::encoding::Context) -> usize {
4708            16
4709        }
4710    }
4711
4712    unsafe impl<D: fidl::encoding::ResourceDialect>
4713        fidl::encoding::Encode<BorderRoutingNat64State, D> for &BorderRoutingNat64State
4714    {
4715        unsafe fn encode(
4716            self,
4717            encoder: &mut fidl::encoding::Encoder<'_, D>,
4718            offset: usize,
4719            mut depth: fidl::encoding::Depth,
4720        ) -> fidl::Result<()> {
4721            encoder.debug_check_bounds::<BorderRoutingNat64State>(offset);
4722            // Vector header
4723            let max_ordinal: u64 = self.max_ordinal_present();
4724            encoder.write_num(max_ordinal, offset);
4725            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4726            // Calling encoder.out_of_line_offset(0) is not allowed.
4727            if max_ordinal == 0 {
4728                return Ok(());
4729            }
4730            depth.increment()?;
4731            let envelope_size = 8;
4732            let bytes_len = max_ordinal as usize * envelope_size;
4733            #[allow(unused_variables)]
4734            let offset = encoder.out_of_line_offset(bytes_len);
4735            let mut _prev_end_offset: usize = 0;
4736            if 1 > max_ordinal {
4737                return Ok(());
4738            }
4739
4740            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4741            // are envelope_size bytes.
4742            let cur_offset: usize = (1 - 1) * envelope_size;
4743
4744            // Zero reserved fields.
4745            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4746
4747            // Safety:
4748            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4749            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4750            //   envelope_size bytes, there is always sufficient room.
4751            fidl::encoding::encode_in_envelope_optional::<Nat64State, D>(
4752                self.prefix_manager_state
4753                    .as_ref()
4754                    .map(<Nat64State as fidl::encoding::ValueTypeMarker>::borrow),
4755                encoder,
4756                offset + cur_offset,
4757                depth,
4758            )?;
4759
4760            _prev_end_offset = cur_offset + envelope_size;
4761            if 2 > max_ordinal {
4762                return Ok(());
4763            }
4764
4765            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4766            // are envelope_size bytes.
4767            let cur_offset: usize = (2 - 1) * envelope_size;
4768
4769            // Zero reserved fields.
4770            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4771
4772            // Safety:
4773            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4774            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4775            //   envelope_size bytes, there is always sufficient room.
4776            fidl::encoding::encode_in_envelope_optional::<Nat64State, D>(
4777                self.translator_state
4778                    .as_ref()
4779                    .map(<Nat64State as fidl::encoding::ValueTypeMarker>::borrow),
4780                encoder,
4781                offset + cur_offset,
4782                depth,
4783            )?;
4784
4785            _prev_end_offset = cur_offset + envelope_size;
4786
4787            Ok(())
4788        }
4789    }
4790
4791    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
4792        for BorderRoutingNat64State
4793    {
4794        #[inline(always)]
4795        fn new_empty() -> Self {
4796            Self::default()
4797        }
4798
4799        unsafe fn decode(
4800            &mut self,
4801            decoder: &mut fidl::encoding::Decoder<'_, D>,
4802            offset: usize,
4803            mut depth: fidl::encoding::Depth,
4804        ) -> fidl::Result<()> {
4805            decoder.debug_check_bounds::<Self>(offset);
4806            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4807                None => return Err(fidl::Error::NotNullable),
4808                Some(len) => len,
4809            };
4810            // Calling decoder.out_of_line_offset(0) is not allowed.
4811            if len == 0 {
4812                return Ok(());
4813            };
4814            depth.increment()?;
4815            let envelope_size = 8;
4816            let bytes_len = len * envelope_size;
4817            let offset = decoder.out_of_line_offset(bytes_len)?;
4818            // Decode the envelope for each type.
4819            let mut _next_ordinal_to_read = 0;
4820            let mut next_offset = offset;
4821            let end_offset = offset + bytes_len;
4822            _next_ordinal_to_read += 1;
4823            if next_offset >= end_offset {
4824                return Ok(());
4825            }
4826
4827            // Decode unknown envelopes for gaps in ordinals.
4828            while _next_ordinal_to_read < 1 {
4829                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4830                _next_ordinal_to_read += 1;
4831                next_offset += envelope_size;
4832            }
4833
4834            let next_out_of_line = decoder.next_out_of_line();
4835            let handles_before = decoder.remaining_handles();
4836            if let Some((inlined, num_bytes, num_handles)) =
4837                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4838            {
4839                let member_inline_size =
4840                    <Nat64State as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4841                if inlined != (member_inline_size <= 4) {
4842                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4843                }
4844                let inner_offset;
4845                let mut inner_depth = depth.clone();
4846                if inlined {
4847                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4848                    inner_offset = next_offset;
4849                } else {
4850                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4851                    inner_depth.increment()?;
4852                }
4853                let val_ref = self
4854                    .prefix_manager_state
4855                    .get_or_insert_with(|| fidl::new_empty!(Nat64State, D));
4856                fidl::decode!(Nat64State, D, val_ref, decoder, inner_offset, inner_depth)?;
4857                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4858                {
4859                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4860                }
4861                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4862                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4863                }
4864            }
4865
4866            next_offset += envelope_size;
4867            _next_ordinal_to_read += 1;
4868            if next_offset >= end_offset {
4869                return Ok(());
4870            }
4871
4872            // Decode unknown envelopes for gaps in ordinals.
4873            while _next_ordinal_to_read < 2 {
4874                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4875                _next_ordinal_to_read += 1;
4876                next_offset += envelope_size;
4877            }
4878
4879            let next_out_of_line = decoder.next_out_of_line();
4880            let handles_before = decoder.remaining_handles();
4881            if let Some((inlined, num_bytes, num_handles)) =
4882                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4883            {
4884                let member_inline_size =
4885                    <Nat64State as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4886                if inlined != (member_inline_size <= 4) {
4887                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4888                }
4889                let inner_offset;
4890                let mut inner_depth = depth.clone();
4891                if inlined {
4892                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4893                    inner_offset = next_offset;
4894                } else {
4895                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4896                    inner_depth.increment()?;
4897                }
4898                let val_ref =
4899                    self.translator_state.get_or_insert_with(|| fidl::new_empty!(Nat64State, D));
4900                fidl::decode!(Nat64State, D, val_ref, decoder, inner_offset, inner_depth)?;
4901                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4902                {
4903                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4904                }
4905                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4906                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4907                }
4908            }
4909
4910            next_offset += envelope_size;
4911
4912            // Decode the remaining unknown envelopes.
4913            while next_offset < end_offset {
4914                _next_ordinal_to_read += 1;
4915                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4916                next_offset += envelope_size;
4917            }
4918
4919            Ok(())
4920        }
4921    }
4922
4923    impl ChannelInfo {
4924        #[inline(always)]
4925        fn max_ordinal_present(&self) -> u64 {
4926            if let Some(_) = self.masked_by_regulatory_domain {
4927                return 6;
4928            }
4929            if let Some(_) = self.spectrum_bandwidth_hz {
4930                return 5;
4931            }
4932            if let Some(_) = self.spectrum_center_frequency_hz {
4933                return 4;
4934            }
4935            if let Some(_) = self.max_transmit_power_dbm {
4936                return 3;
4937            }
4938            if let Some(_) = self.id {
4939                return 2;
4940            }
4941            if let Some(_) = self.index {
4942                return 1;
4943            }
4944            0
4945        }
4946    }
4947
4948    impl fidl::encoding::ValueTypeMarker for ChannelInfo {
4949        type Borrowed<'a> = &'a Self;
4950        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4951            value
4952        }
4953    }
4954
4955    unsafe impl fidl::encoding::TypeMarker for ChannelInfo {
4956        type Owned = Self;
4957
4958        #[inline(always)]
4959        fn inline_align(_context: fidl::encoding::Context) -> usize {
4960            8
4961        }
4962
4963        #[inline(always)]
4964        fn inline_size(_context: fidl::encoding::Context) -> usize {
4965            16
4966        }
4967    }
4968
4969    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ChannelInfo, D>
4970        for &ChannelInfo
4971    {
4972        unsafe fn encode(
4973            self,
4974            encoder: &mut fidl::encoding::Encoder<'_, D>,
4975            offset: usize,
4976            mut depth: fidl::encoding::Depth,
4977        ) -> fidl::Result<()> {
4978            encoder.debug_check_bounds::<ChannelInfo>(offset);
4979            // Vector header
4980            let max_ordinal: u64 = self.max_ordinal_present();
4981            encoder.write_num(max_ordinal, offset);
4982            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4983            // Calling encoder.out_of_line_offset(0) is not allowed.
4984            if max_ordinal == 0 {
4985                return Ok(());
4986            }
4987            depth.increment()?;
4988            let envelope_size = 8;
4989            let bytes_len = max_ordinal as usize * envelope_size;
4990            #[allow(unused_variables)]
4991            let offset = encoder.out_of_line_offset(bytes_len);
4992            let mut _prev_end_offset: usize = 0;
4993            if 1 > max_ordinal {
4994                return Ok(());
4995            }
4996
4997            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4998            // are envelope_size bytes.
4999            let cur_offset: usize = (1 - 1) * envelope_size;
5000
5001            // Zero reserved fields.
5002            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5003
5004            // Safety:
5005            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5006            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5007            //   envelope_size bytes, there is always sufficient room.
5008            fidl::encoding::encode_in_envelope_optional::<u16, D>(
5009                self.index.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5010                encoder,
5011                offset + cur_offset,
5012                depth,
5013            )?;
5014
5015            _prev_end_offset = cur_offset + envelope_size;
5016            if 2 > max_ordinal {
5017                return Ok(());
5018            }
5019
5020            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5021            // are envelope_size bytes.
5022            let cur_offset: usize = (2 - 1) * envelope_size;
5023
5024            // Zero reserved fields.
5025            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5026
5027            // Safety:
5028            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5029            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5030            //   envelope_size bytes, there is always sufficient room.
5031            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<16>, D>(
5032                self.id.as_ref().map(
5033                    <fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow,
5034                ),
5035                encoder,
5036                offset + cur_offset,
5037                depth,
5038            )?;
5039
5040            _prev_end_offset = cur_offset + envelope_size;
5041            if 3 > max_ordinal {
5042                return Ok(());
5043            }
5044
5045            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5046            // are envelope_size bytes.
5047            let cur_offset: usize = (3 - 1) * envelope_size;
5048
5049            // Zero reserved fields.
5050            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5051
5052            // Safety:
5053            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5054            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5055            //   envelope_size bytes, there is always sufficient room.
5056            fidl::encoding::encode_in_envelope_optional::<i8, D>(
5057                self.max_transmit_power_dbm
5058                    .as_ref()
5059                    .map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
5060                encoder,
5061                offset + cur_offset,
5062                depth,
5063            )?;
5064
5065            _prev_end_offset = cur_offset + envelope_size;
5066            if 4 > max_ordinal {
5067                return Ok(());
5068            }
5069
5070            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5071            // are envelope_size bytes.
5072            let cur_offset: usize = (4 - 1) * envelope_size;
5073
5074            // Zero reserved fields.
5075            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5076
5077            // Safety:
5078            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5079            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5080            //   envelope_size bytes, there is always sufficient room.
5081            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5082                self.spectrum_center_frequency_hz
5083                    .as_ref()
5084                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5085                encoder,
5086                offset + cur_offset,
5087                depth,
5088            )?;
5089
5090            _prev_end_offset = cur_offset + envelope_size;
5091            if 5 > max_ordinal {
5092                return Ok(());
5093            }
5094
5095            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5096            // are envelope_size bytes.
5097            let cur_offset: usize = (5 - 1) * envelope_size;
5098
5099            // Zero reserved fields.
5100            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5101
5102            // Safety:
5103            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5104            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5105            //   envelope_size bytes, there is always sufficient room.
5106            fidl::encoding::encode_in_envelope_optional::<u64, D>(
5107                self.spectrum_bandwidth_hz
5108                    .as_ref()
5109                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
5110                encoder,
5111                offset + cur_offset,
5112                depth,
5113            )?;
5114
5115            _prev_end_offset = cur_offset + envelope_size;
5116            if 6 > max_ordinal {
5117                return Ok(());
5118            }
5119
5120            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5121            // are envelope_size bytes.
5122            let cur_offset: usize = (6 - 1) * envelope_size;
5123
5124            // Zero reserved fields.
5125            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5126
5127            // Safety:
5128            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5129            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5130            //   envelope_size bytes, there is always sufficient room.
5131            fidl::encoding::encode_in_envelope_optional::<bool, D>(
5132                self.masked_by_regulatory_domain
5133                    .as_ref()
5134                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
5135                encoder,
5136                offset + cur_offset,
5137                depth,
5138            )?;
5139
5140            _prev_end_offset = cur_offset + envelope_size;
5141
5142            Ok(())
5143        }
5144    }
5145
5146    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ChannelInfo {
5147        #[inline(always)]
5148        fn new_empty() -> Self {
5149            Self::default()
5150        }
5151
5152        unsafe fn decode(
5153            &mut self,
5154            decoder: &mut fidl::encoding::Decoder<'_, D>,
5155            offset: usize,
5156            mut depth: fidl::encoding::Depth,
5157        ) -> fidl::Result<()> {
5158            decoder.debug_check_bounds::<Self>(offset);
5159            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5160                None => return Err(fidl::Error::NotNullable),
5161                Some(len) => len,
5162            };
5163            // Calling decoder.out_of_line_offset(0) is not allowed.
5164            if len == 0 {
5165                return Ok(());
5166            };
5167            depth.increment()?;
5168            let envelope_size = 8;
5169            let bytes_len = len * envelope_size;
5170            let offset = decoder.out_of_line_offset(bytes_len)?;
5171            // Decode the envelope for each type.
5172            let mut _next_ordinal_to_read = 0;
5173            let mut next_offset = offset;
5174            let end_offset = offset + bytes_len;
5175            _next_ordinal_to_read += 1;
5176            if next_offset >= end_offset {
5177                return Ok(());
5178            }
5179
5180            // Decode unknown envelopes for gaps in ordinals.
5181            while _next_ordinal_to_read < 1 {
5182                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5183                _next_ordinal_to_read += 1;
5184                next_offset += envelope_size;
5185            }
5186
5187            let next_out_of_line = decoder.next_out_of_line();
5188            let handles_before = decoder.remaining_handles();
5189            if let Some((inlined, num_bytes, num_handles)) =
5190                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5191            {
5192                let member_inline_size =
5193                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5194                if inlined != (member_inline_size <= 4) {
5195                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5196                }
5197                let inner_offset;
5198                let mut inner_depth = depth.clone();
5199                if inlined {
5200                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5201                    inner_offset = next_offset;
5202                } else {
5203                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5204                    inner_depth.increment()?;
5205                }
5206                let val_ref = self.index.get_or_insert_with(|| fidl::new_empty!(u16, D));
5207                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5208                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5209                {
5210                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5211                }
5212                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5213                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5214                }
5215            }
5216
5217            next_offset += envelope_size;
5218            _next_ordinal_to_read += 1;
5219            if next_offset >= end_offset {
5220                return Ok(());
5221            }
5222
5223            // Decode unknown envelopes for gaps in ordinals.
5224            while _next_ordinal_to_read < 2 {
5225                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5226                _next_ordinal_to_read += 1;
5227                next_offset += envelope_size;
5228            }
5229
5230            let next_out_of_line = decoder.next_out_of_line();
5231            let handles_before = decoder.remaining_handles();
5232            if let Some((inlined, num_bytes, num_handles)) =
5233                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5234            {
5235                let member_inline_size =
5236                    <fidl::encoding::BoundedString<16> as fidl::encoding::TypeMarker>::inline_size(
5237                        decoder.context,
5238                    );
5239                if inlined != (member_inline_size <= 4) {
5240                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5241                }
5242                let inner_offset;
5243                let mut inner_depth = depth.clone();
5244                if inlined {
5245                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5246                    inner_offset = next_offset;
5247                } else {
5248                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5249                    inner_depth.increment()?;
5250                }
5251                let val_ref = self
5252                    .id
5253                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<16>, D));
5254                fidl::decode!(
5255                    fidl::encoding::BoundedString<16>,
5256                    D,
5257                    val_ref,
5258                    decoder,
5259                    inner_offset,
5260                    inner_depth
5261                )?;
5262                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5263                {
5264                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5265                }
5266                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5267                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5268                }
5269            }
5270
5271            next_offset += envelope_size;
5272            _next_ordinal_to_read += 1;
5273            if next_offset >= end_offset {
5274                return Ok(());
5275            }
5276
5277            // Decode unknown envelopes for gaps in ordinals.
5278            while _next_ordinal_to_read < 3 {
5279                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5280                _next_ordinal_to_read += 1;
5281                next_offset += envelope_size;
5282            }
5283
5284            let next_out_of_line = decoder.next_out_of_line();
5285            let handles_before = decoder.remaining_handles();
5286            if let Some((inlined, num_bytes, num_handles)) =
5287                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5288            {
5289                let member_inline_size =
5290                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5291                if inlined != (member_inline_size <= 4) {
5292                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5293                }
5294                let inner_offset;
5295                let mut inner_depth = depth.clone();
5296                if inlined {
5297                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5298                    inner_offset = next_offset;
5299                } else {
5300                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5301                    inner_depth.increment()?;
5302                }
5303                let val_ref =
5304                    self.max_transmit_power_dbm.get_or_insert_with(|| fidl::new_empty!(i8, D));
5305                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
5306                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5307                {
5308                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5309                }
5310                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5311                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5312                }
5313            }
5314
5315            next_offset += envelope_size;
5316            _next_ordinal_to_read += 1;
5317            if next_offset >= end_offset {
5318                return Ok(());
5319            }
5320
5321            // Decode unknown envelopes for gaps in ordinals.
5322            while _next_ordinal_to_read < 4 {
5323                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5324                _next_ordinal_to_read += 1;
5325                next_offset += envelope_size;
5326            }
5327
5328            let next_out_of_line = decoder.next_out_of_line();
5329            let handles_before = decoder.remaining_handles();
5330            if let Some((inlined, num_bytes, num_handles)) =
5331                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5332            {
5333                let member_inline_size =
5334                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5335                if inlined != (member_inline_size <= 4) {
5336                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5337                }
5338                let inner_offset;
5339                let mut inner_depth = depth.clone();
5340                if inlined {
5341                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5342                    inner_offset = next_offset;
5343                } else {
5344                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5345                    inner_depth.increment()?;
5346                }
5347                let val_ref = self
5348                    .spectrum_center_frequency_hz
5349                    .get_or_insert_with(|| fidl::new_empty!(u64, D));
5350                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5351                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5352                {
5353                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5354                }
5355                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5356                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5357                }
5358            }
5359
5360            next_offset += envelope_size;
5361            _next_ordinal_to_read += 1;
5362            if next_offset >= end_offset {
5363                return Ok(());
5364            }
5365
5366            // Decode unknown envelopes for gaps in ordinals.
5367            while _next_ordinal_to_read < 5 {
5368                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5369                _next_ordinal_to_read += 1;
5370                next_offset += envelope_size;
5371            }
5372
5373            let next_out_of_line = decoder.next_out_of_line();
5374            let handles_before = decoder.remaining_handles();
5375            if let Some((inlined, num_bytes, num_handles)) =
5376                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5377            {
5378                let member_inline_size =
5379                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5380                if inlined != (member_inline_size <= 4) {
5381                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5382                }
5383                let inner_offset;
5384                let mut inner_depth = depth.clone();
5385                if inlined {
5386                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5387                    inner_offset = next_offset;
5388                } else {
5389                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5390                    inner_depth.increment()?;
5391                }
5392                let val_ref =
5393                    self.spectrum_bandwidth_hz.get_or_insert_with(|| fidl::new_empty!(u64, D));
5394                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
5395                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5396                {
5397                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5398                }
5399                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5400                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5401                }
5402            }
5403
5404            next_offset += envelope_size;
5405            _next_ordinal_to_read += 1;
5406            if next_offset >= end_offset {
5407                return Ok(());
5408            }
5409
5410            // Decode unknown envelopes for gaps in ordinals.
5411            while _next_ordinal_to_read < 6 {
5412                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5413                _next_ordinal_to_read += 1;
5414                next_offset += envelope_size;
5415            }
5416
5417            let next_out_of_line = decoder.next_out_of_line();
5418            let handles_before = decoder.remaining_handles();
5419            if let Some((inlined, num_bytes, num_handles)) =
5420                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5421            {
5422                let member_inline_size =
5423                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5424                if inlined != (member_inline_size <= 4) {
5425                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5426                }
5427                let inner_offset;
5428                let mut inner_depth = depth.clone();
5429                if inlined {
5430                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5431                    inner_offset = next_offset;
5432                } else {
5433                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5434                    inner_depth.increment()?;
5435                }
5436                let val_ref = self
5437                    .masked_by_regulatory_domain
5438                    .get_or_insert_with(|| fidl::new_empty!(bool, D));
5439                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
5440                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5441                {
5442                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5443                }
5444                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5445                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5446                }
5447            }
5448
5449            next_offset += envelope_size;
5450
5451            // Decode the remaining unknown envelopes.
5452            while next_offset < end_offset {
5453                _next_ordinal_to_read += 1;
5454                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5455                next_offset += envelope_size;
5456            }
5457
5458            Ok(())
5459        }
5460    }
5461
5462    impl Dhcp6PdInfo {
5463        #[inline(always)]
5464        fn max_ordinal_present(&self) -> u64 {
5465            if let Some(_) = self.hashed_pd_prefix {
5466                return 3;
5467            }
5468            if let Some(_) = self.pd_processed_ra_info {
5469                return 2;
5470            }
5471            if let Some(_) = self.dhcp6pd_state {
5472                return 1;
5473            }
5474            0
5475        }
5476    }
5477
5478    impl fidl::encoding::ValueTypeMarker for Dhcp6PdInfo {
5479        type Borrowed<'a> = &'a Self;
5480        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5481            value
5482        }
5483    }
5484
5485    unsafe impl fidl::encoding::TypeMarker for Dhcp6PdInfo {
5486        type Owned = Self;
5487
5488        #[inline(always)]
5489        fn inline_align(_context: fidl::encoding::Context) -> usize {
5490            8
5491        }
5492
5493        #[inline(always)]
5494        fn inline_size(_context: fidl::encoding::Context) -> usize {
5495            16
5496        }
5497    }
5498
5499    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Dhcp6PdInfo, D>
5500        for &Dhcp6PdInfo
5501    {
5502        unsafe fn encode(
5503            self,
5504            encoder: &mut fidl::encoding::Encoder<'_, D>,
5505            offset: usize,
5506            mut depth: fidl::encoding::Depth,
5507        ) -> fidl::Result<()> {
5508            encoder.debug_check_bounds::<Dhcp6PdInfo>(offset);
5509            // Vector header
5510            let max_ordinal: u64 = self.max_ordinal_present();
5511            encoder.write_num(max_ordinal, offset);
5512            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5513            // Calling encoder.out_of_line_offset(0) is not allowed.
5514            if max_ordinal == 0 {
5515                return Ok(());
5516            }
5517            depth.increment()?;
5518            let envelope_size = 8;
5519            let bytes_len = max_ordinal as usize * envelope_size;
5520            #[allow(unused_variables)]
5521            let offset = encoder.out_of_line_offset(bytes_len);
5522            let mut _prev_end_offset: usize = 0;
5523            if 1 > max_ordinal {
5524                return Ok(());
5525            }
5526
5527            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5528            // are envelope_size bytes.
5529            let cur_offset: usize = (1 - 1) * envelope_size;
5530
5531            // Zero reserved fields.
5532            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5533
5534            // Safety:
5535            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5536            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5537            //   envelope_size bytes, there is always sufficient room.
5538            fidl::encoding::encode_in_envelope_optional::<Dhcp6PdState, D>(
5539                self.dhcp6pd_state
5540                    .as_ref()
5541                    .map(<Dhcp6PdState as fidl::encoding::ValueTypeMarker>::borrow),
5542                encoder,
5543                offset + cur_offset,
5544                depth,
5545            )?;
5546
5547            _prev_end_offset = cur_offset + envelope_size;
5548            if 2 > max_ordinal {
5549                return Ok(());
5550            }
5551
5552            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5553            // are envelope_size bytes.
5554            let cur_offset: usize = (2 - 1) * envelope_size;
5555
5556            // Zero reserved fields.
5557            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5558
5559            // Safety:
5560            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5561            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5562            //   envelope_size bytes, there is always sufficient room.
5563            fidl::encoding::encode_in_envelope_optional::<PdProcessedRaInfo, D>(
5564                self.pd_processed_ra_info
5565                    .as_ref()
5566                    .map(<PdProcessedRaInfo as fidl::encoding::ValueTypeMarker>::borrow),
5567                encoder,
5568                offset + cur_offset,
5569                depth,
5570            )?;
5571
5572            _prev_end_offset = cur_offset + envelope_size;
5573            if 3 > max_ordinal {
5574                return Ok(());
5575            }
5576
5577            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5578            // are envelope_size bytes.
5579            let cur_offset: usize = (3 - 1) * envelope_size;
5580
5581            // Zero reserved fields.
5582            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5583
5584            // Safety:
5585            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5586            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5587            //   envelope_size bytes, there is always sufficient room.
5588            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 32>, D>(
5589                self.hashed_pd_prefix.as_ref().map(
5590                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
5591                ),
5592                encoder,
5593                offset + cur_offset,
5594                depth,
5595            )?;
5596
5597            _prev_end_offset = cur_offset + envelope_size;
5598
5599            Ok(())
5600        }
5601    }
5602
5603    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Dhcp6PdInfo {
5604        #[inline(always)]
5605        fn new_empty() -> Self {
5606            Self::default()
5607        }
5608
5609        unsafe fn decode(
5610            &mut self,
5611            decoder: &mut fidl::encoding::Decoder<'_, D>,
5612            offset: usize,
5613            mut depth: fidl::encoding::Depth,
5614        ) -> fidl::Result<()> {
5615            decoder.debug_check_bounds::<Self>(offset);
5616            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5617                None => return Err(fidl::Error::NotNullable),
5618                Some(len) => len,
5619            };
5620            // Calling decoder.out_of_line_offset(0) is not allowed.
5621            if len == 0 {
5622                return Ok(());
5623            };
5624            depth.increment()?;
5625            let envelope_size = 8;
5626            let bytes_len = len * envelope_size;
5627            let offset = decoder.out_of_line_offset(bytes_len)?;
5628            // Decode the envelope for each type.
5629            let mut _next_ordinal_to_read = 0;
5630            let mut next_offset = offset;
5631            let end_offset = offset + bytes_len;
5632            _next_ordinal_to_read += 1;
5633            if next_offset >= end_offset {
5634                return Ok(());
5635            }
5636
5637            // Decode unknown envelopes for gaps in ordinals.
5638            while _next_ordinal_to_read < 1 {
5639                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5640                _next_ordinal_to_read += 1;
5641                next_offset += envelope_size;
5642            }
5643
5644            let next_out_of_line = decoder.next_out_of_line();
5645            let handles_before = decoder.remaining_handles();
5646            if let Some((inlined, num_bytes, num_handles)) =
5647                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5648            {
5649                let member_inline_size =
5650                    <Dhcp6PdState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5651                if inlined != (member_inline_size <= 4) {
5652                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5653                }
5654                let inner_offset;
5655                let mut inner_depth = depth.clone();
5656                if inlined {
5657                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5658                    inner_offset = next_offset;
5659                } else {
5660                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5661                    inner_depth.increment()?;
5662                }
5663                let val_ref =
5664                    self.dhcp6pd_state.get_or_insert_with(|| fidl::new_empty!(Dhcp6PdState, D));
5665                fidl::decode!(Dhcp6PdState, D, val_ref, decoder, inner_offset, inner_depth)?;
5666                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5667                {
5668                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5669                }
5670                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5671                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5672                }
5673            }
5674
5675            next_offset += envelope_size;
5676            _next_ordinal_to_read += 1;
5677            if next_offset >= end_offset {
5678                return Ok(());
5679            }
5680
5681            // Decode unknown envelopes for gaps in ordinals.
5682            while _next_ordinal_to_read < 2 {
5683                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5684                _next_ordinal_to_read += 1;
5685                next_offset += envelope_size;
5686            }
5687
5688            let next_out_of_line = decoder.next_out_of_line();
5689            let handles_before = decoder.remaining_handles();
5690            if let Some((inlined, num_bytes, num_handles)) =
5691                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5692            {
5693                let member_inline_size =
5694                    <PdProcessedRaInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5695                if inlined != (member_inline_size <= 4) {
5696                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5697                }
5698                let inner_offset;
5699                let mut inner_depth = depth.clone();
5700                if inlined {
5701                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5702                    inner_offset = next_offset;
5703                } else {
5704                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5705                    inner_depth.increment()?;
5706                }
5707                let val_ref = self
5708                    .pd_processed_ra_info
5709                    .get_or_insert_with(|| fidl::new_empty!(PdProcessedRaInfo, D));
5710                fidl::decode!(PdProcessedRaInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
5711                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5712                {
5713                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5714                }
5715                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5716                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5717                }
5718            }
5719
5720            next_offset += envelope_size;
5721            _next_ordinal_to_read += 1;
5722            if next_offset >= end_offset {
5723                return Ok(());
5724            }
5725
5726            // Decode unknown envelopes for gaps in ordinals.
5727            while _next_ordinal_to_read < 3 {
5728                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5729                _next_ordinal_to_read += 1;
5730                next_offset += envelope_size;
5731            }
5732
5733            let next_out_of_line = decoder.next_out_of_line();
5734            let handles_before = decoder.remaining_handles();
5735            if let Some((inlined, num_bytes, num_handles)) =
5736                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5737            {
5738                let member_inline_size =
5739                    <fidl::encoding::Vector<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
5740                        decoder.context,
5741                    );
5742                if inlined != (member_inline_size <= 4) {
5743                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5744                }
5745                let inner_offset;
5746                let mut inner_depth = depth.clone();
5747                if inlined {
5748                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5749                    inner_offset = next_offset;
5750                } else {
5751                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5752                    inner_depth.increment()?;
5753                }
5754                let val_ref = self
5755                    .hashed_pd_prefix
5756                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 32>, D));
5757                fidl::decode!(fidl::encoding::Vector<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
5758                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5759                {
5760                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5761                }
5762                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5763                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5764                }
5765            }
5766
5767            next_offset += envelope_size;
5768
5769            // Decode the remaining unknown envelopes.
5770            while next_offset < end_offset {
5771                _next_ordinal_to_read += 1;
5772                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5773                next_offset += envelope_size;
5774            }
5775
5776            Ok(())
5777        }
5778    }
5779
5780    impl DnssdCounters {
5781        #[inline(always)]
5782        fn max_ordinal_present(&self) -> u64 {
5783            if let Some(_) = self.upstream_dns_counters {
5784                return 8;
5785            }
5786            if let Some(_) = self.resolved_by_srp {
5787                return 7;
5788            }
5789            if let Some(_) = self.other_response {
5790                return 6;
5791            }
5792            if let Some(_) = self.not_implemented_response {
5793                return 5;
5794            }
5795            if let Some(_) = self.name_error_response {
5796                return 4;
5797            }
5798            if let Some(_) = self.format_error_response {
5799                return 3;
5800            }
5801            if let Some(_) = self.server_failure_response {
5802                return 2;
5803            }
5804            if let Some(_) = self.success_response {
5805                return 1;
5806            }
5807            0
5808        }
5809    }
5810
5811    impl fidl::encoding::ValueTypeMarker for DnssdCounters {
5812        type Borrowed<'a> = &'a Self;
5813        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5814            value
5815        }
5816    }
5817
5818    unsafe impl fidl::encoding::TypeMarker for DnssdCounters {
5819        type Owned = Self;
5820
5821        #[inline(always)]
5822        fn inline_align(_context: fidl::encoding::Context) -> usize {
5823            8
5824        }
5825
5826        #[inline(always)]
5827        fn inline_size(_context: fidl::encoding::Context) -> usize {
5828            16
5829        }
5830    }
5831
5832    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DnssdCounters, D>
5833        for &DnssdCounters
5834    {
5835        unsafe fn encode(
5836            self,
5837            encoder: &mut fidl::encoding::Encoder<'_, D>,
5838            offset: usize,
5839            mut depth: fidl::encoding::Depth,
5840        ) -> fidl::Result<()> {
5841            encoder.debug_check_bounds::<DnssdCounters>(offset);
5842            // Vector header
5843            let max_ordinal: u64 = self.max_ordinal_present();
5844            encoder.write_num(max_ordinal, offset);
5845            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5846            // Calling encoder.out_of_line_offset(0) is not allowed.
5847            if max_ordinal == 0 {
5848                return Ok(());
5849            }
5850            depth.increment()?;
5851            let envelope_size = 8;
5852            let bytes_len = max_ordinal as usize * envelope_size;
5853            #[allow(unused_variables)]
5854            let offset = encoder.out_of_line_offset(bytes_len);
5855            let mut _prev_end_offset: usize = 0;
5856            if 1 > max_ordinal {
5857                return Ok(());
5858            }
5859
5860            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5861            // are envelope_size bytes.
5862            let cur_offset: usize = (1 - 1) * envelope_size;
5863
5864            // Zero reserved fields.
5865            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5866
5867            // Safety:
5868            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5869            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5870            //   envelope_size bytes, there is always sufficient room.
5871            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5872                self.success_response
5873                    .as_ref()
5874                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5875                encoder,
5876                offset + cur_offset,
5877                depth,
5878            )?;
5879
5880            _prev_end_offset = cur_offset + envelope_size;
5881            if 2 > max_ordinal {
5882                return Ok(());
5883            }
5884
5885            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5886            // are envelope_size bytes.
5887            let cur_offset: usize = (2 - 1) * envelope_size;
5888
5889            // Zero reserved fields.
5890            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5891
5892            // Safety:
5893            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5894            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5895            //   envelope_size bytes, there is always sufficient room.
5896            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5897                self.server_failure_response
5898                    .as_ref()
5899                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5900                encoder,
5901                offset + cur_offset,
5902                depth,
5903            )?;
5904
5905            _prev_end_offset = cur_offset + envelope_size;
5906            if 3 > max_ordinal {
5907                return Ok(());
5908            }
5909
5910            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5911            // are envelope_size bytes.
5912            let cur_offset: usize = (3 - 1) * envelope_size;
5913
5914            // Zero reserved fields.
5915            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5916
5917            // Safety:
5918            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5919            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5920            //   envelope_size bytes, there is always sufficient room.
5921            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5922                self.format_error_response
5923                    .as_ref()
5924                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5925                encoder,
5926                offset + cur_offset,
5927                depth,
5928            )?;
5929
5930            _prev_end_offset = cur_offset + envelope_size;
5931            if 4 > max_ordinal {
5932                return Ok(());
5933            }
5934
5935            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5936            // are envelope_size bytes.
5937            let cur_offset: usize = (4 - 1) * envelope_size;
5938
5939            // Zero reserved fields.
5940            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5941
5942            // Safety:
5943            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5944            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5945            //   envelope_size bytes, there is always sufficient room.
5946            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5947                self.name_error_response
5948                    .as_ref()
5949                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5950                encoder,
5951                offset + cur_offset,
5952                depth,
5953            )?;
5954
5955            _prev_end_offset = cur_offset + envelope_size;
5956            if 5 > max_ordinal {
5957                return Ok(());
5958            }
5959
5960            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5961            // are envelope_size bytes.
5962            let cur_offset: usize = (5 - 1) * envelope_size;
5963
5964            // Zero reserved fields.
5965            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5966
5967            // Safety:
5968            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5969            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5970            //   envelope_size bytes, there is always sufficient room.
5971            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5972                self.not_implemented_response
5973                    .as_ref()
5974                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5975                encoder,
5976                offset + cur_offset,
5977                depth,
5978            )?;
5979
5980            _prev_end_offset = cur_offset + envelope_size;
5981            if 6 > max_ordinal {
5982                return Ok(());
5983            }
5984
5985            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5986            // are envelope_size bytes.
5987            let cur_offset: usize = (6 - 1) * envelope_size;
5988
5989            // Zero reserved fields.
5990            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5991
5992            // Safety:
5993            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5994            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5995            //   envelope_size bytes, there is always sufficient room.
5996            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5997                self.other_response.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5998                encoder,
5999                offset + cur_offset,
6000                depth,
6001            )?;
6002
6003            _prev_end_offset = cur_offset + envelope_size;
6004            if 7 > max_ordinal {
6005                return Ok(());
6006            }
6007
6008            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6009            // are envelope_size bytes.
6010            let cur_offset: usize = (7 - 1) * envelope_size;
6011
6012            // Zero reserved fields.
6013            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6014
6015            // Safety:
6016            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6017            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6018            //   envelope_size bytes, there is always sufficient room.
6019            fidl::encoding::encode_in_envelope_optional::<u32, D>(
6020                self.resolved_by_srp.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
6021                encoder,
6022                offset + cur_offset,
6023                depth,
6024            )?;
6025
6026            _prev_end_offset = cur_offset + envelope_size;
6027            if 8 > max_ordinal {
6028                return Ok(());
6029            }
6030
6031            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6032            // are envelope_size bytes.
6033            let cur_offset: usize = (8 - 1) * envelope_size;
6034
6035            // Zero reserved fields.
6036            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6037
6038            // Safety:
6039            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6040            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6041            //   envelope_size bytes, there is always sufficient room.
6042            fidl::encoding::encode_in_envelope_optional::<UpstreamDnsCounters, D>(
6043                self.upstream_dns_counters
6044                    .as_ref()
6045                    .map(<UpstreamDnsCounters as fidl::encoding::ValueTypeMarker>::borrow),
6046                encoder,
6047                offset + cur_offset,
6048                depth,
6049            )?;
6050
6051            _prev_end_offset = cur_offset + envelope_size;
6052
6053            Ok(())
6054        }
6055    }
6056
6057    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DnssdCounters {
6058        #[inline(always)]
6059        fn new_empty() -> Self {
6060            Self::default()
6061        }
6062
6063        unsafe fn decode(
6064            &mut self,
6065            decoder: &mut fidl::encoding::Decoder<'_, D>,
6066            offset: usize,
6067            mut depth: fidl::encoding::Depth,
6068        ) -> fidl::Result<()> {
6069            decoder.debug_check_bounds::<Self>(offset);
6070            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6071                None => return Err(fidl::Error::NotNullable),
6072                Some(len) => len,
6073            };
6074            // Calling decoder.out_of_line_offset(0) is not allowed.
6075            if len == 0 {
6076                return Ok(());
6077            };
6078            depth.increment()?;
6079            let envelope_size = 8;
6080            let bytes_len = len * envelope_size;
6081            let offset = decoder.out_of_line_offset(bytes_len)?;
6082            // Decode the envelope for each type.
6083            let mut _next_ordinal_to_read = 0;
6084            let mut next_offset = offset;
6085            let end_offset = offset + bytes_len;
6086            _next_ordinal_to_read += 1;
6087            if next_offset >= end_offset {
6088                return Ok(());
6089            }
6090
6091            // Decode unknown envelopes for gaps in ordinals.
6092            while _next_ordinal_to_read < 1 {
6093                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6094                _next_ordinal_to_read += 1;
6095                next_offset += envelope_size;
6096            }
6097
6098            let next_out_of_line = decoder.next_out_of_line();
6099            let handles_before = decoder.remaining_handles();
6100            if let Some((inlined, num_bytes, num_handles)) =
6101                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6102            {
6103                let member_inline_size =
6104                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6105                if inlined != (member_inline_size <= 4) {
6106                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6107                }
6108                let inner_offset;
6109                let mut inner_depth = depth.clone();
6110                if inlined {
6111                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6112                    inner_offset = next_offset;
6113                } else {
6114                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6115                    inner_depth.increment()?;
6116                }
6117                let val_ref = self.success_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6118                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6119                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6120                {
6121                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6122                }
6123                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6124                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6125                }
6126            }
6127
6128            next_offset += envelope_size;
6129            _next_ordinal_to_read += 1;
6130            if next_offset >= end_offset {
6131                return Ok(());
6132            }
6133
6134            // Decode unknown envelopes for gaps in ordinals.
6135            while _next_ordinal_to_read < 2 {
6136                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6137                _next_ordinal_to_read += 1;
6138                next_offset += envelope_size;
6139            }
6140
6141            let next_out_of_line = decoder.next_out_of_line();
6142            let handles_before = decoder.remaining_handles();
6143            if let Some((inlined, num_bytes, num_handles)) =
6144                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6145            {
6146                let member_inline_size =
6147                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6148                if inlined != (member_inline_size <= 4) {
6149                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6150                }
6151                let inner_offset;
6152                let mut inner_depth = depth.clone();
6153                if inlined {
6154                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6155                    inner_offset = next_offset;
6156                } else {
6157                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6158                    inner_depth.increment()?;
6159                }
6160                let val_ref =
6161                    self.server_failure_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6162                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6163                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6164                {
6165                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6166                }
6167                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6168                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6169                }
6170            }
6171
6172            next_offset += envelope_size;
6173            _next_ordinal_to_read += 1;
6174            if next_offset >= end_offset {
6175                return Ok(());
6176            }
6177
6178            // Decode unknown envelopes for gaps in ordinals.
6179            while _next_ordinal_to_read < 3 {
6180                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6181                _next_ordinal_to_read += 1;
6182                next_offset += envelope_size;
6183            }
6184
6185            let next_out_of_line = decoder.next_out_of_line();
6186            let handles_before = decoder.remaining_handles();
6187            if let Some((inlined, num_bytes, num_handles)) =
6188                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6189            {
6190                let member_inline_size =
6191                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6192                if inlined != (member_inline_size <= 4) {
6193                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6194                }
6195                let inner_offset;
6196                let mut inner_depth = depth.clone();
6197                if inlined {
6198                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6199                    inner_offset = next_offset;
6200                } else {
6201                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6202                    inner_depth.increment()?;
6203                }
6204                let val_ref =
6205                    self.format_error_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6206                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6207                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6208                {
6209                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6210                }
6211                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6212                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6213                }
6214            }
6215
6216            next_offset += envelope_size;
6217            _next_ordinal_to_read += 1;
6218            if next_offset >= end_offset {
6219                return Ok(());
6220            }
6221
6222            // Decode unknown envelopes for gaps in ordinals.
6223            while _next_ordinal_to_read < 4 {
6224                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6225                _next_ordinal_to_read += 1;
6226                next_offset += envelope_size;
6227            }
6228
6229            let next_out_of_line = decoder.next_out_of_line();
6230            let handles_before = decoder.remaining_handles();
6231            if let Some((inlined, num_bytes, num_handles)) =
6232                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6233            {
6234                let member_inline_size =
6235                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6236                if inlined != (member_inline_size <= 4) {
6237                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6238                }
6239                let inner_offset;
6240                let mut inner_depth = depth.clone();
6241                if inlined {
6242                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6243                    inner_offset = next_offset;
6244                } else {
6245                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6246                    inner_depth.increment()?;
6247                }
6248                let val_ref =
6249                    self.name_error_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6250                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6251                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6252                {
6253                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6254                }
6255                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6256                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6257                }
6258            }
6259
6260            next_offset += envelope_size;
6261            _next_ordinal_to_read += 1;
6262            if next_offset >= end_offset {
6263                return Ok(());
6264            }
6265
6266            // Decode unknown envelopes for gaps in ordinals.
6267            while _next_ordinal_to_read < 5 {
6268                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6269                _next_ordinal_to_read += 1;
6270                next_offset += envelope_size;
6271            }
6272
6273            let next_out_of_line = decoder.next_out_of_line();
6274            let handles_before = decoder.remaining_handles();
6275            if let Some((inlined, num_bytes, num_handles)) =
6276                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6277            {
6278                let member_inline_size =
6279                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6280                if inlined != (member_inline_size <= 4) {
6281                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6282                }
6283                let inner_offset;
6284                let mut inner_depth = depth.clone();
6285                if inlined {
6286                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6287                    inner_offset = next_offset;
6288                } else {
6289                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6290                    inner_depth.increment()?;
6291                }
6292                let val_ref =
6293                    self.not_implemented_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6294                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6295                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6296                {
6297                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6298                }
6299                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6300                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6301                }
6302            }
6303
6304            next_offset += envelope_size;
6305            _next_ordinal_to_read += 1;
6306            if next_offset >= end_offset {
6307                return Ok(());
6308            }
6309
6310            // Decode unknown envelopes for gaps in ordinals.
6311            while _next_ordinal_to_read < 6 {
6312                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6313                _next_ordinal_to_read += 1;
6314                next_offset += envelope_size;
6315            }
6316
6317            let next_out_of_line = decoder.next_out_of_line();
6318            let handles_before = decoder.remaining_handles();
6319            if let Some((inlined, num_bytes, num_handles)) =
6320                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6321            {
6322                let member_inline_size =
6323                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6324                if inlined != (member_inline_size <= 4) {
6325                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6326                }
6327                let inner_offset;
6328                let mut inner_depth = depth.clone();
6329                if inlined {
6330                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6331                    inner_offset = next_offset;
6332                } else {
6333                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6334                    inner_depth.increment()?;
6335                }
6336                let val_ref = self.other_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
6337                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6338                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6339                {
6340                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6341                }
6342                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6343                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6344                }
6345            }
6346
6347            next_offset += envelope_size;
6348            _next_ordinal_to_read += 1;
6349            if next_offset >= end_offset {
6350                return Ok(());
6351            }
6352
6353            // Decode unknown envelopes for gaps in ordinals.
6354            while _next_ordinal_to_read < 7 {
6355                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6356                _next_ordinal_to_read += 1;
6357                next_offset += envelope_size;
6358            }
6359
6360            let next_out_of_line = decoder.next_out_of_line();
6361            let handles_before = decoder.remaining_handles();
6362            if let Some((inlined, num_bytes, num_handles)) =
6363                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6364            {
6365                let member_inline_size =
6366                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6367                if inlined != (member_inline_size <= 4) {
6368                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6369                }
6370                let inner_offset;
6371                let mut inner_depth = depth.clone();
6372                if inlined {
6373                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6374                    inner_offset = next_offset;
6375                } else {
6376                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6377                    inner_depth.increment()?;
6378                }
6379                let val_ref = self.resolved_by_srp.get_or_insert_with(|| fidl::new_empty!(u32, D));
6380                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6381                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6382                {
6383                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6384                }
6385                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6386                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6387                }
6388            }
6389
6390            next_offset += envelope_size;
6391            _next_ordinal_to_read += 1;
6392            if next_offset >= end_offset {
6393                return Ok(());
6394            }
6395
6396            // Decode unknown envelopes for gaps in ordinals.
6397            while _next_ordinal_to_read < 8 {
6398                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6399                _next_ordinal_to_read += 1;
6400                next_offset += envelope_size;
6401            }
6402
6403            let next_out_of_line = decoder.next_out_of_line();
6404            let handles_before = decoder.remaining_handles();
6405            if let Some((inlined, num_bytes, num_handles)) =
6406                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6407            {
6408                let member_inline_size =
6409                    <UpstreamDnsCounters as fidl::encoding::TypeMarker>::inline_size(
6410                        decoder.context,
6411                    );
6412                if inlined != (member_inline_size <= 4) {
6413                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6414                }
6415                let inner_offset;
6416                let mut inner_depth = depth.clone();
6417                if inlined {
6418                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6419                    inner_offset = next_offset;
6420                } else {
6421                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6422                    inner_depth.increment()?;
6423                }
6424                let val_ref = self
6425                    .upstream_dns_counters
6426                    .get_or_insert_with(|| fidl::new_empty!(UpstreamDnsCounters, D));
6427                fidl::decode!(UpstreamDnsCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
6428                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6429                {
6430                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6431                }
6432                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6433                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6434                }
6435            }
6436
6437            next_offset += envelope_size;
6438
6439            // Decode the remaining unknown envelopes.
6440            while next_offset < end_offset {
6441                _next_ordinal_to_read += 1;
6442                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6443                next_offset += envelope_size;
6444            }
6445
6446            Ok(())
6447        }
6448    }
6449
6450    impl ExternalRoute {
6451        #[inline(always)]
6452        fn max_ordinal_present(&self) -> u64 {
6453            if let Some(_) = self.stable {
6454                return 3;
6455            }
6456            if let Some(_) = self.route_preference {
6457                return 2;
6458            }
6459            if let Some(_) = self.subnet {
6460                return 1;
6461            }
6462            0
6463        }
6464    }
6465
6466    impl fidl::encoding::ValueTypeMarker for ExternalRoute {
6467        type Borrowed<'a> = &'a Self;
6468        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6469            value
6470        }
6471    }
6472
6473    unsafe impl fidl::encoding::TypeMarker for ExternalRoute {
6474        type Owned = Self;
6475
6476        #[inline(always)]
6477        fn inline_align(_context: fidl::encoding::Context) -> usize {
6478            8
6479        }
6480
6481        #[inline(always)]
6482        fn inline_size(_context: fidl::encoding::Context) -> usize {
6483            16
6484        }
6485    }
6486
6487    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ExternalRoute, D>
6488        for &ExternalRoute
6489    {
6490        unsafe fn encode(
6491            self,
6492            encoder: &mut fidl::encoding::Encoder<'_, D>,
6493            offset: usize,
6494            mut depth: fidl::encoding::Depth,
6495        ) -> fidl::Result<()> {
6496            encoder.debug_check_bounds::<ExternalRoute>(offset);
6497            // Vector header
6498            let max_ordinal: u64 = self.max_ordinal_present();
6499            encoder.write_num(max_ordinal, offset);
6500            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6501            // Calling encoder.out_of_line_offset(0) is not allowed.
6502            if max_ordinal == 0 {
6503                return Ok(());
6504            }
6505            depth.increment()?;
6506            let envelope_size = 8;
6507            let bytes_len = max_ordinal as usize * envelope_size;
6508            #[allow(unused_variables)]
6509            let offset = encoder.out_of_line_offset(bytes_len);
6510            let mut _prev_end_offset: usize = 0;
6511            if 1 > max_ordinal {
6512                return Ok(());
6513            }
6514
6515            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6516            // are envelope_size bytes.
6517            let cur_offset: usize = (1 - 1) * envelope_size;
6518
6519            // Zero reserved fields.
6520            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6521
6522            // Safety:
6523            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6524            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6525            //   envelope_size bytes, there is always sufficient room.
6526            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>(
6527            self.subnet.as_ref().map(<fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow),
6528            encoder, offset + cur_offset, depth
6529        )?;
6530
6531            _prev_end_offset = cur_offset + envelope_size;
6532            if 2 > max_ordinal {
6533                return Ok(());
6534            }
6535
6536            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6537            // are envelope_size bytes.
6538            let cur_offset: usize = (2 - 1) * envelope_size;
6539
6540            // Zero reserved fields.
6541            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6542
6543            // Safety:
6544            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6545            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6546            //   envelope_size bytes, there is always sufficient room.
6547            fidl::encoding::encode_in_envelope_optional::<RoutePreference, D>(
6548                self.route_preference
6549                    .as_ref()
6550                    .map(<RoutePreference as fidl::encoding::ValueTypeMarker>::borrow),
6551                encoder,
6552                offset + cur_offset,
6553                depth,
6554            )?;
6555
6556            _prev_end_offset = cur_offset + envelope_size;
6557            if 3 > max_ordinal {
6558                return Ok(());
6559            }
6560
6561            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6562            // are envelope_size bytes.
6563            let cur_offset: usize = (3 - 1) * envelope_size;
6564
6565            // Zero reserved fields.
6566            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6567
6568            // Safety:
6569            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6570            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6571            //   envelope_size bytes, there is always sufficient room.
6572            fidl::encoding::encode_in_envelope_optional::<bool, D>(
6573                self.stable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6574                encoder,
6575                offset + cur_offset,
6576                depth,
6577            )?;
6578
6579            _prev_end_offset = cur_offset + envelope_size;
6580
6581            Ok(())
6582        }
6583    }
6584
6585    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ExternalRoute {
6586        #[inline(always)]
6587        fn new_empty() -> Self {
6588            Self::default()
6589        }
6590
6591        unsafe fn decode(
6592            &mut self,
6593            decoder: &mut fidl::encoding::Decoder<'_, D>,
6594            offset: usize,
6595            mut depth: fidl::encoding::Depth,
6596        ) -> fidl::Result<()> {
6597            decoder.debug_check_bounds::<Self>(offset);
6598            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6599                None => return Err(fidl::Error::NotNullable),
6600                Some(len) => len,
6601            };
6602            // Calling decoder.out_of_line_offset(0) is not allowed.
6603            if len == 0 {
6604                return Ok(());
6605            };
6606            depth.increment()?;
6607            let envelope_size = 8;
6608            let bytes_len = len * envelope_size;
6609            let offset = decoder.out_of_line_offset(bytes_len)?;
6610            // Decode the envelope for each type.
6611            let mut _next_ordinal_to_read = 0;
6612            let mut next_offset = offset;
6613            let end_offset = offset + bytes_len;
6614            _next_ordinal_to_read += 1;
6615            if next_offset >= end_offset {
6616                return Ok(());
6617            }
6618
6619            // Decode unknown envelopes for gaps in ordinals.
6620            while _next_ordinal_to_read < 1 {
6621                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6622                _next_ordinal_to_read += 1;
6623                next_offset += envelope_size;
6624            }
6625
6626            let next_out_of_line = decoder.next_out_of_line();
6627            let handles_before = decoder.remaining_handles();
6628            if let Some((inlined, num_bytes, num_handles)) =
6629                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6630            {
6631                let member_inline_size = <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6632                if inlined != (member_inline_size <= 4) {
6633                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6634                }
6635                let inner_offset;
6636                let mut inner_depth = depth.clone();
6637                if inlined {
6638                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6639                    inner_offset = next_offset;
6640                } else {
6641                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6642                    inner_depth.increment()?;
6643                }
6644                let val_ref = self.subnet.get_or_insert_with(|| {
6645                    fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D)
6646                });
6647                fidl::decode!(
6648                    fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
6649                    D,
6650                    val_ref,
6651                    decoder,
6652                    inner_offset,
6653                    inner_depth
6654                )?;
6655                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6656                {
6657                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6658                }
6659                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6660                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6661                }
6662            }
6663
6664            next_offset += envelope_size;
6665            _next_ordinal_to_read += 1;
6666            if next_offset >= end_offset {
6667                return Ok(());
6668            }
6669
6670            // Decode unknown envelopes for gaps in ordinals.
6671            while _next_ordinal_to_read < 2 {
6672                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6673                _next_ordinal_to_read += 1;
6674                next_offset += envelope_size;
6675            }
6676
6677            let next_out_of_line = decoder.next_out_of_line();
6678            let handles_before = decoder.remaining_handles();
6679            if let Some((inlined, num_bytes, num_handles)) =
6680                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6681            {
6682                let member_inline_size =
6683                    <RoutePreference as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6684                if inlined != (member_inline_size <= 4) {
6685                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6686                }
6687                let inner_offset;
6688                let mut inner_depth = depth.clone();
6689                if inlined {
6690                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6691                    inner_offset = next_offset;
6692                } else {
6693                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6694                    inner_depth.increment()?;
6695                }
6696                let val_ref = self
6697                    .route_preference
6698                    .get_or_insert_with(|| fidl::new_empty!(RoutePreference, D));
6699                fidl::decode!(RoutePreference, D, val_ref, decoder, inner_offset, inner_depth)?;
6700                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6701                {
6702                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6703                }
6704                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6705                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6706                }
6707            }
6708
6709            next_offset += envelope_size;
6710            _next_ordinal_to_read += 1;
6711            if next_offset >= end_offset {
6712                return Ok(());
6713            }
6714
6715            // Decode unknown envelopes for gaps in ordinals.
6716            while _next_ordinal_to_read < 3 {
6717                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6718                _next_ordinal_to_read += 1;
6719                next_offset += envelope_size;
6720            }
6721
6722            let next_out_of_line = decoder.next_out_of_line();
6723            let handles_before = decoder.remaining_handles();
6724            if let Some((inlined, num_bytes, num_handles)) =
6725                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6726            {
6727                let member_inline_size =
6728                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6729                if inlined != (member_inline_size <= 4) {
6730                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6731                }
6732                let inner_offset;
6733                let mut inner_depth = depth.clone();
6734                if inlined {
6735                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6736                    inner_offset = next_offset;
6737                } else {
6738                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6739                    inner_depth.increment()?;
6740                }
6741                let val_ref = self.stable.get_or_insert_with(|| fidl::new_empty!(bool, D));
6742                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6743                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6744                {
6745                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6746                }
6747                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6748                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6749                }
6750            }
6751
6752            next_offset += envelope_size;
6753
6754            // Decode the remaining unknown envelopes.
6755            while next_offset < end_offset {
6756                _next_ordinal_to_read += 1;
6757                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6758                next_offset += envelope_size;
6759            }
6760
6761            Ok(())
6762        }
6763    }
6764
6765    impl JoinerCommissioningParams {
6766        #[inline(always)]
6767        fn max_ordinal_present(&self) -> u64 {
6768            if let Some(_) = self.vendor_data_string {
6769                return 6;
6770            }
6771            if let Some(_) = self.vendor_sw_version {
6772                return 5;
6773            }
6774            if let Some(_) = self.vendor_model {
6775                return 4;
6776            }
6777            if let Some(_) = self.vendor_name {
6778                return 3;
6779            }
6780            if let Some(_) = self.provisioning_url {
6781                return 2;
6782            }
6783            if let Some(_) = self.pskd {
6784                return 1;
6785            }
6786            0
6787        }
6788    }
6789
6790    impl fidl::encoding::ValueTypeMarker for JoinerCommissioningParams {
6791        type Borrowed<'a> = &'a Self;
6792        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6793            value
6794        }
6795    }
6796
6797    unsafe impl fidl::encoding::TypeMarker for JoinerCommissioningParams {
6798        type Owned = Self;
6799
6800        #[inline(always)]
6801        fn inline_align(_context: fidl::encoding::Context) -> usize {
6802            8
6803        }
6804
6805        #[inline(always)]
6806        fn inline_size(_context: fidl::encoding::Context) -> usize {
6807            16
6808        }
6809    }
6810
6811    unsafe impl<D: fidl::encoding::ResourceDialect>
6812        fidl::encoding::Encode<JoinerCommissioningParams, D> for &JoinerCommissioningParams
6813    {
6814        unsafe fn encode(
6815            self,
6816            encoder: &mut fidl::encoding::Encoder<'_, D>,
6817            offset: usize,
6818            mut depth: fidl::encoding::Depth,
6819        ) -> fidl::Result<()> {
6820            encoder.debug_check_bounds::<JoinerCommissioningParams>(offset);
6821            // Vector header
6822            let max_ordinal: u64 = self.max_ordinal_present();
6823            encoder.write_num(max_ordinal, offset);
6824            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6825            // Calling encoder.out_of_line_offset(0) is not allowed.
6826            if max_ordinal == 0 {
6827                return Ok(());
6828            }
6829            depth.increment()?;
6830            let envelope_size = 8;
6831            let bytes_len = max_ordinal as usize * envelope_size;
6832            #[allow(unused_variables)]
6833            let offset = encoder.out_of_line_offset(bytes_len);
6834            let mut _prev_end_offset: usize = 0;
6835            if 1 > max_ordinal {
6836                return Ok(());
6837            }
6838
6839            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6840            // are envelope_size bytes.
6841            let cur_offset: usize = (1 - 1) * envelope_size;
6842
6843            // Zero reserved fields.
6844            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6845
6846            // Safety:
6847            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6848            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6849            //   envelope_size bytes, there is always sufficient room.
6850            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<32>, D>(
6851                self.pskd.as_ref().map(
6852                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow,
6853                ),
6854                encoder,
6855                offset + cur_offset,
6856                depth,
6857            )?;
6858
6859            _prev_end_offset = cur_offset + envelope_size;
6860            if 2 > max_ordinal {
6861                return Ok(());
6862            }
6863
6864            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6865            // are envelope_size bytes.
6866            let cur_offset: usize = (2 - 1) * envelope_size;
6867
6868            // Zero reserved fields.
6869            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6870
6871            // Safety:
6872            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6873            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6874            //   envelope_size bytes, there is always sufficient room.
6875            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
6876                self.provisioning_url.as_ref().map(
6877                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
6878                ),
6879                encoder,
6880                offset + cur_offset,
6881                depth,
6882            )?;
6883
6884            _prev_end_offset = cur_offset + envelope_size;
6885            if 3 > max_ordinal {
6886                return Ok(());
6887            }
6888
6889            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6890            // are envelope_size bytes.
6891            let cur_offset: usize = (3 - 1) * envelope_size;
6892
6893            // Zero reserved fields.
6894            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6895
6896            // Safety:
6897            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6898            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6899            //   envelope_size bytes, there is always sufficient room.
6900            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<32>, D>(
6901                self.vendor_name.as_ref().map(
6902                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow,
6903                ),
6904                encoder,
6905                offset + cur_offset,
6906                depth,
6907            )?;
6908
6909            _prev_end_offset = cur_offset + envelope_size;
6910            if 4 > max_ordinal {
6911                return Ok(());
6912            }
6913
6914            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6915            // are envelope_size bytes.
6916            let cur_offset: usize = (4 - 1) * envelope_size;
6917
6918            // Zero reserved fields.
6919            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6920
6921            // Safety:
6922            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6923            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6924            //   envelope_size bytes, there is always sufficient room.
6925            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<32>, D>(
6926                self.vendor_model.as_ref().map(
6927                    <fidl::encoding::BoundedString<32> as fidl::encoding::ValueTypeMarker>::borrow,
6928                ),
6929                encoder,
6930                offset + cur_offset,
6931                depth,
6932            )?;
6933
6934            _prev_end_offset = cur_offset + envelope_size;
6935            if 5 > max_ordinal {
6936                return Ok(());
6937            }
6938
6939            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6940            // are envelope_size bytes.
6941            let cur_offset: usize = (5 - 1) * envelope_size;
6942
6943            // Zero reserved fields.
6944            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6945
6946            // Safety:
6947            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6948            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6949            //   envelope_size bytes, there is always sufficient room.
6950            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<16>, D>(
6951                self.vendor_sw_version.as_ref().map(
6952                    <fidl::encoding::BoundedString<16> as fidl::encoding::ValueTypeMarker>::borrow,
6953                ),
6954                encoder,
6955                offset + cur_offset,
6956                depth,
6957            )?;
6958
6959            _prev_end_offset = cur_offset + envelope_size;
6960            if 6 > max_ordinal {
6961                return Ok(());
6962            }
6963
6964            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6965            // are envelope_size bytes.
6966            let cur_offset: usize = (6 - 1) * envelope_size;
6967
6968            // Zero reserved fields.
6969            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6970
6971            // Safety:
6972            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6973            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6974            //   envelope_size bytes, there is always sufficient room.
6975            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<64>, D>(
6976                self.vendor_data_string.as_ref().map(
6977                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow,
6978                ),
6979                encoder,
6980                offset + cur_offset,
6981                depth,
6982            )?;
6983
6984            _prev_end_offset = cur_offset + envelope_size;
6985
6986            Ok(())
6987        }
6988    }
6989
6990    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
6991        for JoinerCommissioningParams
6992    {
6993        #[inline(always)]
6994        fn new_empty() -> Self {
6995            Self::default()
6996        }
6997
6998        unsafe fn decode(
6999            &mut self,
7000            decoder: &mut fidl::encoding::Decoder<'_, D>,
7001            offset: usize,
7002            mut depth: fidl::encoding::Depth,
7003        ) -> fidl::Result<()> {
7004            decoder.debug_check_bounds::<Self>(offset);
7005            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7006                None => return Err(fidl::Error::NotNullable),
7007                Some(len) => len,
7008            };
7009            // Calling decoder.out_of_line_offset(0) is not allowed.
7010            if len == 0 {
7011                return Ok(());
7012            };
7013            depth.increment()?;
7014            let envelope_size = 8;
7015            let bytes_len = len * envelope_size;
7016            let offset = decoder.out_of_line_offset(bytes_len)?;
7017            // Decode the envelope for each type.
7018            let mut _next_ordinal_to_read = 0;
7019            let mut next_offset = offset;
7020            let end_offset = offset + bytes_len;
7021            _next_ordinal_to_read += 1;
7022            if next_offset >= end_offset {
7023                return Ok(());
7024            }
7025
7026            // Decode unknown envelopes for gaps in ordinals.
7027            while _next_ordinal_to_read < 1 {
7028                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7029                _next_ordinal_to_read += 1;
7030                next_offset += envelope_size;
7031            }
7032
7033            let next_out_of_line = decoder.next_out_of_line();
7034            let handles_before = decoder.remaining_handles();
7035            if let Some((inlined, num_bytes, num_handles)) =
7036                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7037            {
7038                let member_inline_size =
7039                    <fidl::encoding::BoundedString<32> as fidl::encoding::TypeMarker>::inline_size(
7040                        decoder.context,
7041                    );
7042                if inlined != (member_inline_size <= 4) {
7043                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7044                }
7045                let inner_offset;
7046                let mut inner_depth = depth.clone();
7047                if inlined {
7048                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7049                    inner_offset = next_offset;
7050                } else {
7051                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7052                    inner_depth.increment()?;
7053                }
7054                let val_ref = self
7055                    .pskd
7056                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<32>, D));
7057                fidl::decode!(
7058                    fidl::encoding::BoundedString<32>,
7059                    D,
7060                    val_ref,
7061                    decoder,
7062                    inner_offset,
7063                    inner_depth
7064                )?;
7065                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7066                {
7067                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7068                }
7069                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7070                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7071                }
7072            }
7073
7074            next_offset += envelope_size;
7075            _next_ordinal_to_read += 1;
7076            if next_offset >= end_offset {
7077                return Ok(());
7078            }
7079
7080            // Decode unknown envelopes for gaps in ordinals.
7081            while _next_ordinal_to_read < 2 {
7082                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7083                _next_ordinal_to_read += 1;
7084                next_offset += envelope_size;
7085            }
7086
7087            let next_out_of_line = decoder.next_out_of_line();
7088            let handles_before = decoder.remaining_handles();
7089            if let Some((inlined, num_bytes, num_handles)) =
7090                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7091            {
7092                let member_inline_size =
7093                    <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
7094                        decoder.context,
7095                    );
7096                if inlined != (member_inline_size <= 4) {
7097                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7098                }
7099                let inner_offset;
7100                let mut inner_depth = depth.clone();
7101                if inlined {
7102                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7103                    inner_offset = next_offset;
7104                } else {
7105                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7106                    inner_depth.increment()?;
7107                }
7108                let val_ref = self
7109                    .provisioning_url
7110                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
7111                fidl::decode!(
7112                    fidl::encoding::BoundedString<64>,
7113                    D,
7114                    val_ref,
7115                    decoder,
7116                    inner_offset,
7117                    inner_depth
7118                )?;
7119                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7120                {
7121                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7122                }
7123                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7124                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7125                }
7126            }
7127
7128            next_offset += envelope_size;
7129            _next_ordinal_to_read += 1;
7130            if next_offset >= end_offset {
7131                return Ok(());
7132            }
7133
7134            // Decode unknown envelopes for gaps in ordinals.
7135            while _next_ordinal_to_read < 3 {
7136                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7137                _next_ordinal_to_read += 1;
7138                next_offset += envelope_size;
7139            }
7140
7141            let next_out_of_line = decoder.next_out_of_line();
7142            let handles_before = decoder.remaining_handles();
7143            if let Some((inlined, num_bytes, num_handles)) =
7144                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7145            {
7146                let member_inline_size =
7147                    <fidl::encoding::BoundedString<32> as fidl::encoding::TypeMarker>::inline_size(
7148                        decoder.context,
7149                    );
7150                if inlined != (member_inline_size <= 4) {
7151                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7152                }
7153                let inner_offset;
7154                let mut inner_depth = depth.clone();
7155                if inlined {
7156                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7157                    inner_offset = next_offset;
7158                } else {
7159                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7160                    inner_depth.increment()?;
7161                }
7162                let val_ref = self
7163                    .vendor_name
7164                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<32>, D));
7165                fidl::decode!(
7166                    fidl::encoding::BoundedString<32>,
7167                    D,
7168                    val_ref,
7169                    decoder,
7170                    inner_offset,
7171                    inner_depth
7172                )?;
7173                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7174                {
7175                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7176                }
7177                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7178                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7179                }
7180            }
7181
7182            next_offset += envelope_size;
7183            _next_ordinal_to_read += 1;
7184            if next_offset >= end_offset {
7185                return Ok(());
7186            }
7187
7188            // Decode unknown envelopes for gaps in ordinals.
7189            while _next_ordinal_to_read < 4 {
7190                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7191                _next_ordinal_to_read += 1;
7192                next_offset += envelope_size;
7193            }
7194
7195            let next_out_of_line = decoder.next_out_of_line();
7196            let handles_before = decoder.remaining_handles();
7197            if let Some((inlined, num_bytes, num_handles)) =
7198                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7199            {
7200                let member_inline_size =
7201                    <fidl::encoding::BoundedString<32> as fidl::encoding::TypeMarker>::inline_size(
7202                        decoder.context,
7203                    );
7204                if inlined != (member_inline_size <= 4) {
7205                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7206                }
7207                let inner_offset;
7208                let mut inner_depth = depth.clone();
7209                if inlined {
7210                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7211                    inner_offset = next_offset;
7212                } else {
7213                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7214                    inner_depth.increment()?;
7215                }
7216                let val_ref = self
7217                    .vendor_model
7218                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<32>, D));
7219                fidl::decode!(
7220                    fidl::encoding::BoundedString<32>,
7221                    D,
7222                    val_ref,
7223                    decoder,
7224                    inner_offset,
7225                    inner_depth
7226                )?;
7227                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7228                {
7229                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7230                }
7231                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7232                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7233                }
7234            }
7235
7236            next_offset += envelope_size;
7237            _next_ordinal_to_read += 1;
7238            if next_offset >= end_offset {
7239                return Ok(());
7240            }
7241
7242            // Decode unknown envelopes for gaps in ordinals.
7243            while _next_ordinal_to_read < 5 {
7244                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7245                _next_ordinal_to_read += 1;
7246                next_offset += envelope_size;
7247            }
7248
7249            let next_out_of_line = decoder.next_out_of_line();
7250            let handles_before = decoder.remaining_handles();
7251            if let Some((inlined, num_bytes, num_handles)) =
7252                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7253            {
7254                let member_inline_size =
7255                    <fidl::encoding::BoundedString<16> as fidl::encoding::TypeMarker>::inline_size(
7256                        decoder.context,
7257                    );
7258                if inlined != (member_inline_size <= 4) {
7259                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7260                }
7261                let inner_offset;
7262                let mut inner_depth = depth.clone();
7263                if inlined {
7264                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7265                    inner_offset = next_offset;
7266                } else {
7267                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7268                    inner_depth.increment()?;
7269                }
7270                let val_ref = self
7271                    .vendor_sw_version
7272                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<16>, D));
7273                fidl::decode!(
7274                    fidl::encoding::BoundedString<16>,
7275                    D,
7276                    val_ref,
7277                    decoder,
7278                    inner_offset,
7279                    inner_depth
7280                )?;
7281                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7282                {
7283                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7284                }
7285                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7286                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7287                }
7288            }
7289
7290            next_offset += envelope_size;
7291            _next_ordinal_to_read += 1;
7292            if next_offset >= end_offset {
7293                return Ok(());
7294            }
7295
7296            // Decode unknown envelopes for gaps in ordinals.
7297            while _next_ordinal_to_read < 6 {
7298                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7299                _next_ordinal_to_read += 1;
7300                next_offset += envelope_size;
7301            }
7302
7303            let next_out_of_line = decoder.next_out_of_line();
7304            let handles_before = decoder.remaining_handles();
7305            if let Some((inlined, num_bytes, num_handles)) =
7306                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7307            {
7308                let member_inline_size =
7309                    <fidl::encoding::BoundedString<64> as fidl::encoding::TypeMarker>::inline_size(
7310                        decoder.context,
7311                    );
7312                if inlined != (member_inline_size <= 4) {
7313                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7314                }
7315                let inner_offset;
7316                let mut inner_depth = depth.clone();
7317                if inlined {
7318                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7319                    inner_offset = next_offset;
7320                } else {
7321                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7322                    inner_depth.increment()?;
7323                }
7324                let val_ref = self
7325                    .vendor_data_string
7326                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<64>, D));
7327                fidl::decode!(
7328                    fidl::encoding::BoundedString<64>,
7329                    D,
7330                    val_ref,
7331                    decoder,
7332                    inner_offset,
7333                    inner_depth
7334                )?;
7335                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7336                {
7337                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7338                }
7339                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7340                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7341                }
7342            }
7343
7344            next_offset += envelope_size;
7345
7346            // Decode the remaining unknown envelopes.
7347            while next_offset < end_offset {
7348                _next_ordinal_to_read += 1;
7349                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7350                next_offset += envelope_size;
7351            }
7352
7353            Ok(())
7354        }
7355    }
7356
7357    impl LeaderData {
7358        #[inline(always)]
7359        fn max_ordinal_present(&self) -> u64 {
7360            if let Some(_) = self.router_id {
7361                return 5;
7362            }
7363            if let Some(_) = self.stable_network_data_version {
7364                return 4;
7365            }
7366            if let Some(_) = self.network_data_version {
7367                return 3;
7368            }
7369            if let Some(_) = self.weight {
7370                return 2;
7371            }
7372            if let Some(_) = self.partition_id {
7373                return 1;
7374            }
7375            0
7376        }
7377    }
7378
7379    impl fidl::encoding::ValueTypeMarker for LeaderData {
7380        type Borrowed<'a> = &'a Self;
7381        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7382            value
7383        }
7384    }
7385
7386    unsafe impl fidl::encoding::TypeMarker for LeaderData {
7387        type Owned = Self;
7388
7389        #[inline(always)]
7390        fn inline_align(_context: fidl::encoding::Context) -> usize {
7391            8
7392        }
7393
7394        #[inline(always)]
7395        fn inline_size(_context: fidl::encoding::Context) -> usize {
7396            16
7397        }
7398    }
7399
7400    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LeaderData, D>
7401        for &LeaderData
7402    {
7403        unsafe fn encode(
7404            self,
7405            encoder: &mut fidl::encoding::Encoder<'_, D>,
7406            offset: usize,
7407            mut depth: fidl::encoding::Depth,
7408        ) -> fidl::Result<()> {
7409            encoder.debug_check_bounds::<LeaderData>(offset);
7410            // Vector header
7411            let max_ordinal: u64 = self.max_ordinal_present();
7412            encoder.write_num(max_ordinal, offset);
7413            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7414            // Calling encoder.out_of_line_offset(0) is not allowed.
7415            if max_ordinal == 0 {
7416                return Ok(());
7417            }
7418            depth.increment()?;
7419            let envelope_size = 8;
7420            let bytes_len = max_ordinal as usize * envelope_size;
7421            #[allow(unused_variables)]
7422            let offset = encoder.out_of_line_offset(bytes_len);
7423            let mut _prev_end_offset: usize = 0;
7424            if 1 > max_ordinal {
7425                return Ok(());
7426            }
7427
7428            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7429            // are envelope_size bytes.
7430            let cur_offset: usize = (1 - 1) * envelope_size;
7431
7432            // Zero reserved fields.
7433            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7434
7435            // Safety:
7436            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7437            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7438            //   envelope_size bytes, there is always sufficient room.
7439            fidl::encoding::encode_in_envelope_optional::<u32, D>(
7440                self.partition_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
7441                encoder,
7442                offset + cur_offset,
7443                depth,
7444            )?;
7445
7446            _prev_end_offset = cur_offset + envelope_size;
7447            if 2 > max_ordinal {
7448                return Ok(());
7449            }
7450
7451            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7452            // are envelope_size bytes.
7453            let cur_offset: usize = (2 - 1) * envelope_size;
7454
7455            // Zero reserved fields.
7456            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7457
7458            // Safety:
7459            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7460            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7461            //   envelope_size bytes, there is always sufficient room.
7462            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7463                self.weight.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7464                encoder,
7465                offset + cur_offset,
7466                depth,
7467            )?;
7468
7469            _prev_end_offset = cur_offset + envelope_size;
7470            if 3 > max_ordinal {
7471                return Ok(());
7472            }
7473
7474            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7475            // are envelope_size bytes.
7476            let cur_offset: usize = (3 - 1) * envelope_size;
7477
7478            // Zero reserved fields.
7479            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7480
7481            // Safety:
7482            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7483            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7484            //   envelope_size bytes, there is always sufficient room.
7485            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7486                self.network_data_version
7487                    .as_ref()
7488                    .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7489                encoder,
7490                offset + cur_offset,
7491                depth,
7492            )?;
7493
7494            _prev_end_offset = cur_offset + envelope_size;
7495            if 4 > max_ordinal {
7496                return Ok(());
7497            }
7498
7499            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7500            // are envelope_size bytes.
7501            let cur_offset: usize = (4 - 1) * envelope_size;
7502
7503            // Zero reserved fields.
7504            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7505
7506            // Safety:
7507            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7508            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7509            //   envelope_size bytes, there is always sufficient room.
7510            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7511                self.stable_network_data_version
7512                    .as_ref()
7513                    .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7514                encoder,
7515                offset + cur_offset,
7516                depth,
7517            )?;
7518
7519            _prev_end_offset = cur_offset + envelope_size;
7520            if 5 > max_ordinal {
7521                return Ok(());
7522            }
7523
7524            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7525            // are envelope_size bytes.
7526            let cur_offset: usize = (5 - 1) * envelope_size;
7527
7528            // Zero reserved fields.
7529            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7530
7531            // Safety:
7532            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7533            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7534            //   envelope_size bytes, there is always sufficient room.
7535            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7536                self.router_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7537                encoder,
7538                offset + cur_offset,
7539                depth,
7540            )?;
7541
7542            _prev_end_offset = cur_offset + envelope_size;
7543
7544            Ok(())
7545        }
7546    }
7547
7548    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LeaderData {
7549        #[inline(always)]
7550        fn new_empty() -> Self {
7551            Self::default()
7552        }
7553
7554        unsafe fn decode(
7555            &mut self,
7556            decoder: &mut fidl::encoding::Decoder<'_, D>,
7557            offset: usize,
7558            mut depth: fidl::encoding::Depth,
7559        ) -> fidl::Result<()> {
7560            decoder.debug_check_bounds::<Self>(offset);
7561            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7562                None => return Err(fidl::Error::NotNullable),
7563                Some(len) => len,
7564            };
7565            // Calling decoder.out_of_line_offset(0) is not allowed.
7566            if len == 0 {
7567                return Ok(());
7568            };
7569            depth.increment()?;
7570            let envelope_size = 8;
7571            let bytes_len = len * envelope_size;
7572            let offset = decoder.out_of_line_offset(bytes_len)?;
7573            // Decode the envelope for each type.
7574            let mut _next_ordinal_to_read = 0;
7575            let mut next_offset = offset;
7576            let end_offset = offset + bytes_len;
7577            _next_ordinal_to_read += 1;
7578            if next_offset >= end_offset {
7579                return Ok(());
7580            }
7581
7582            // Decode unknown envelopes for gaps in ordinals.
7583            while _next_ordinal_to_read < 1 {
7584                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7585                _next_ordinal_to_read += 1;
7586                next_offset += envelope_size;
7587            }
7588
7589            let next_out_of_line = decoder.next_out_of_line();
7590            let handles_before = decoder.remaining_handles();
7591            if let Some((inlined, num_bytes, num_handles)) =
7592                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7593            {
7594                let member_inline_size =
7595                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7596                if inlined != (member_inline_size <= 4) {
7597                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7598                }
7599                let inner_offset;
7600                let mut inner_depth = depth.clone();
7601                if inlined {
7602                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7603                    inner_offset = next_offset;
7604                } else {
7605                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7606                    inner_depth.increment()?;
7607                }
7608                let val_ref = self.partition_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
7609                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
7610                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7611                {
7612                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7613                }
7614                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7615                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7616                }
7617            }
7618
7619            next_offset += envelope_size;
7620            _next_ordinal_to_read += 1;
7621            if next_offset >= end_offset {
7622                return Ok(());
7623            }
7624
7625            // Decode unknown envelopes for gaps in ordinals.
7626            while _next_ordinal_to_read < 2 {
7627                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7628                _next_ordinal_to_read += 1;
7629                next_offset += envelope_size;
7630            }
7631
7632            let next_out_of_line = decoder.next_out_of_line();
7633            let handles_before = decoder.remaining_handles();
7634            if let Some((inlined, num_bytes, num_handles)) =
7635                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7636            {
7637                let member_inline_size =
7638                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7639                if inlined != (member_inline_size <= 4) {
7640                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7641                }
7642                let inner_offset;
7643                let mut inner_depth = depth.clone();
7644                if inlined {
7645                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7646                    inner_offset = next_offset;
7647                } else {
7648                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7649                    inner_depth.increment()?;
7650                }
7651                let val_ref = self.weight.get_or_insert_with(|| fidl::new_empty!(u8, D));
7652                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7653                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7654                {
7655                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7656                }
7657                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7658                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7659                }
7660            }
7661
7662            next_offset += envelope_size;
7663            _next_ordinal_to_read += 1;
7664            if next_offset >= end_offset {
7665                return Ok(());
7666            }
7667
7668            // Decode unknown envelopes for gaps in ordinals.
7669            while _next_ordinal_to_read < 3 {
7670                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7671                _next_ordinal_to_read += 1;
7672                next_offset += envelope_size;
7673            }
7674
7675            let next_out_of_line = decoder.next_out_of_line();
7676            let handles_before = decoder.remaining_handles();
7677            if let Some((inlined, num_bytes, num_handles)) =
7678                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7679            {
7680                let member_inline_size =
7681                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7682                if inlined != (member_inline_size <= 4) {
7683                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7684                }
7685                let inner_offset;
7686                let mut inner_depth = depth.clone();
7687                if inlined {
7688                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7689                    inner_offset = next_offset;
7690                } else {
7691                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7692                    inner_depth.increment()?;
7693                }
7694                let val_ref =
7695                    self.network_data_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
7696                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7697                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7698                {
7699                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7700                }
7701                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7702                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7703                }
7704            }
7705
7706            next_offset += envelope_size;
7707            _next_ordinal_to_read += 1;
7708            if next_offset >= end_offset {
7709                return Ok(());
7710            }
7711
7712            // Decode unknown envelopes for gaps in ordinals.
7713            while _next_ordinal_to_read < 4 {
7714                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7715                _next_ordinal_to_read += 1;
7716                next_offset += envelope_size;
7717            }
7718
7719            let next_out_of_line = decoder.next_out_of_line();
7720            let handles_before = decoder.remaining_handles();
7721            if let Some((inlined, num_bytes, num_handles)) =
7722                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7723            {
7724                let member_inline_size =
7725                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7726                if inlined != (member_inline_size <= 4) {
7727                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7728                }
7729                let inner_offset;
7730                let mut inner_depth = depth.clone();
7731                if inlined {
7732                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7733                    inner_offset = next_offset;
7734                } else {
7735                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7736                    inner_depth.increment()?;
7737                }
7738                let val_ref =
7739                    self.stable_network_data_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
7740                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7741                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7742                {
7743                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7744                }
7745                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7746                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7747                }
7748            }
7749
7750            next_offset += envelope_size;
7751            _next_ordinal_to_read += 1;
7752            if next_offset >= end_offset {
7753                return Ok(());
7754            }
7755
7756            // Decode unknown envelopes for gaps in ordinals.
7757            while _next_ordinal_to_read < 5 {
7758                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7759                _next_ordinal_to_read += 1;
7760                next_offset += envelope_size;
7761            }
7762
7763            let next_out_of_line = decoder.next_out_of_line();
7764            let handles_before = decoder.remaining_handles();
7765            if let Some((inlined, num_bytes, num_handles)) =
7766                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7767            {
7768                let member_inline_size =
7769                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7770                if inlined != (member_inline_size <= 4) {
7771                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7772                }
7773                let inner_offset;
7774                let mut inner_depth = depth.clone();
7775                if inlined {
7776                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7777                    inner_offset = next_offset;
7778                } else {
7779                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7780                    inner_depth.increment()?;
7781                }
7782                let val_ref = self.router_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
7783                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7784                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7785                {
7786                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7787                }
7788                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7789                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7790                }
7791            }
7792
7793            next_offset += envelope_size;
7794
7795            // Decode the remaining unknown envelopes.
7796            while next_offset < end_offset {
7797                _next_ordinal_to_read += 1;
7798                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7799                next_offset += envelope_size;
7800            }
7801
7802            Ok(())
7803        }
7804    }
7805
7806    impl LinkMetricsEntry {
7807        #[inline(always)]
7808        fn max_ordinal_present(&self) -> u64 {
7809            if let Some(_) = self.rssi {
7810                return 2;
7811            }
7812            if let Some(_) = self.link_margin {
7813                return 1;
7814            }
7815            0
7816        }
7817    }
7818
7819    impl fidl::encoding::ValueTypeMarker for LinkMetricsEntry {
7820        type Borrowed<'a> = &'a Self;
7821        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
7822            value
7823        }
7824    }
7825
7826    unsafe impl fidl::encoding::TypeMarker for LinkMetricsEntry {
7827        type Owned = Self;
7828
7829        #[inline(always)]
7830        fn inline_align(_context: fidl::encoding::Context) -> usize {
7831            8
7832        }
7833
7834        #[inline(always)]
7835        fn inline_size(_context: fidl::encoding::Context) -> usize {
7836            16
7837        }
7838    }
7839
7840    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LinkMetricsEntry, D>
7841        for &LinkMetricsEntry
7842    {
7843        unsafe fn encode(
7844            self,
7845            encoder: &mut fidl::encoding::Encoder<'_, D>,
7846            offset: usize,
7847            mut depth: fidl::encoding::Depth,
7848        ) -> fidl::Result<()> {
7849            encoder.debug_check_bounds::<LinkMetricsEntry>(offset);
7850            // Vector header
7851            let max_ordinal: u64 = self.max_ordinal_present();
7852            encoder.write_num(max_ordinal, offset);
7853            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
7854            // Calling encoder.out_of_line_offset(0) is not allowed.
7855            if max_ordinal == 0 {
7856                return Ok(());
7857            }
7858            depth.increment()?;
7859            let envelope_size = 8;
7860            let bytes_len = max_ordinal as usize * envelope_size;
7861            #[allow(unused_variables)]
7862            let offset = encoder.out_of_line_offset(bytes_len);
7863            let mut _prev_end_offset: usize = 0;
7864            if 1 > max_ordinal {
7865                return Ok(());
7866            }
7867
7868            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7869            // are envelope_size bytes.
7870            let cur_offset: usize = (1 - 1) * envelope_size;
7871
7872            // Zero reserved fields.
7873            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7874
7875            // Safety:
7876            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7877            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7878            //   envelope_size bytes, there is always sufficient room.
7879            fidl::encoding::encode_in_envelope_optional::<u8, D>(
7880                self.link_margin.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
7881                encoder,
7882                offset + cur_offset,
7883                depth,
7884            )?;
7885
7886            _prev_end_offset = cur_offset + envelope_size;
7887            if 2 > max_ordinal {
7888                return Ok(());
7889            }
7890
7891            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
7892            // are envelope_size bytes.
7893            let cur_offset: usize = (2 - 1) * envelope_size;
7894
7895            // Zero reserved fields.
7896            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
7897
7898            // Safety:
7899            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
7900            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
7901            //   envelope_size bytes, there is always sufficient room.
7902            fidl::encoding::encode_in_envelope_optional::<i8, D>(
7903                self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
7904                encoder,
7905                offset + cur_offset,
7906                depth,
7907            )?;
7908
7909            _prev_end_offset = cur_offset + envelope_size;
7910
7911            Ok(())
7912        }
7913    }
7914
7915    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LinkMetricsEntry {
7916        #[inline(always)]
7917        fn new_empty() -> Self {
7918            Self::default()
7919        }
7920
7921        unsafe fn decode(
7922            &mut self,
7923            decoder: &mut fidl::encoding::Decoder<'_, D>,
7924            offset: usize,
7925            mut depth: fidl::encoding::Depth,
7926        ) -> fidl::Result<()> {
7927            decoder.debug_check_bounds::<Self>(offset);
7928            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
7929                None => return Err(fidl::Error::NotNullable),
7930                Some(len) => len,
7931            };
7932            // Calling decoder.out_of_line_offset(0) is not allowed.
7933            if len == 0 {
7934                return Ok(());
7935            };
7936            depth.increment()?;
7937            let envelope_size = 8;
7938            let bytes_len = len * envelope_size;
7939            let offset = decoder.out_of_line_offset(bytes_len)?;
7940            // Decode the envelope for each type.
7941            let mut _next_ordinal_to_read = 0;
7942            let mut next_offset = offset;
7943            let end_offset = offset + bytes_len;
7944            _next_ordinal_to_read += 1;
7945            if next_offset >= end_offset {
7946                return Ok(());
7947            }
7948
7949            // Decode unknown envelopes for gaps in ordinals.
7950            while _next_ordinal_to_read < 1 {
7951                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7952                _next_ordinal_to_read += 1;
7953                next_offset += envelope_size;
7954            }
7955
7956            let next_out_of_line = decoder.next_out_of_line();
7957            let handles_before = decoder.remaining_handles();
7958            if let Some((inlined, num_bytes, num_handles)) =
7959                fidl::encoding::decode_envelope_header(decoder, next_offset)?
7960            {
7961                let member_inline_size =
7962                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
7963                if inlined != (member_inline_size <= 4) {
7964                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
7965                }
7966                let inner_offset;
7967                let mut inner_depth = depth.clone();
7968                if inlined {
7969                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
7970                    inner_offset = next_offset;
7971                } else {
7972                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
7973                    inner_depth.increment()?;
7974                }
7975                let val_ref = self.link_margin.get_or_insert_with(|| fidl::new_empty!(u8, D));
7976                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
7977                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
7978                {
7979                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
7980                }
7981                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
7982                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
7983                }
7984            }
7985
7986            next_offset += envelope_size;
7987            _next_ordinal_to_read += 1;
7988            if next_offset >= end_offset {
7989                return Ok(());
7990            }
7991
7992            // Decode unknown envelopes for gaps in ordinals.
7993            while _next_ordinal_to_read < 2 {
7994                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
7995                _next_ordinal_to_read += 1;
7996                next_offset += envelope_size;
7997            }
7998
7999            let next_out_of_line = decoder.next_out_of_line();
8000            let handles_before = decoder.remaining_handles();
8001            if let Some((inlined, num_bytes, num_handles)) =
8002                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8003            {
8004                let member_inline_size =
8005                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8006                if inlined != (member_inline_size <= 4) {
8007                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8008                }
8009                let inner_offset;
8010                let mut inner_depth = depth.clone();
8011                if inlined {
8012                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8013                    inner_offset = next_offset;
8014                } else {
8015                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8016                    inner_depth.increment()?;
8017                }
8018                let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
8019                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
8020                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8021                {
8022                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8023                }
8024                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8025                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8026                }
8027            }
8028
8029            next_offset += envelope_size;
8030
8031            // Decode the remaining unknown envelopes.
8032            while next_offset < end_offset {
8033                _next_ordinal_to_read += 1;
8034                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8035                next_offset += envelope_size;
8036            }
8037
8038            Ok(())
8039        }
8040    }
8041
8042    impl Nat64ErrorCounters {
8043        #[inline(always)]
8044        fn max_ordinal_present(&self) -> u64 {
8045            if let Some(_) = self.no_mapping {
8046                return 4;
8047            }
8048            if let Some(_) = self.unsupported_protocol {
8049                return 3;
8050            }
8051            if let Some(_) = self.illegal_packet {
8052                return 2;
8053            }
8054            if let Some(_) = self.unknown {
8055                return 1;
8056            }
8057            0
8058        }
8059    }
8060
8061    impl fidl::encoding::ValueTypeMarker for Nat64ErrorCounters {
8062        type Borrowed<'a> = &'a Self;
8063        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8064            value
8065        }
8066    }
8067
8068    unsafe impl fidl::encoding::TypeMarker for Nat64ErrorCounters {
8069        type Owned = Self;
8070
8071        #[inline(always)]
8072        fn inline_align(_context: fidl::encoding::Context) -> usize {
8073            8
8074        }
8075
8076        #[inline(always)]
8077        fn inline_size(_context: fidl::encoding::Context) -> usize {
8078            16
8079        }
8080    }
8081
8082    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64ErrorCounters, D>
8083        for &Nat64ErrorCounters
8084    {
8085        unsafe fn encode(
8086            self,
8087            encoder: &mut fidl::encoding::Encoder<'_, D>,
8088            offset: usize,
8089            mut depth: fidl::encoding::Depth,
8090        ) -> fidl::Result<()> {
8091            encoder.debug_check_bounds::<Nat64ErrorCounters>(offset);
8092            // Vector header
8093            let max_ordinal: u64 = self.max_ordinal_present();
8094            encoder.write_num(max_ordinal, offset);
8095            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8096            // Calling encoder.out_of_line_offset(0) is not allowed.
8097            if max_ordinal == 0 {
8098                return Ok(());
8099            }
8100            depth.increment()?;
8101            let envelope_size = 8;
8102            let bytes_len = max_ordinal as usize * envelope_size;
8103            #[allow(unused_variables)]
8104            let offset = encoder.out_of_line_offset(bytes_len);
8105            let mut _prev_end_offset: usize = 0;
8106            if 1 > max_ordinal {
8107                return Ok(());
8108            }
8109
8110            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8111            // are envelope_size bytes.
8112            let cur_offset: usize = (1 - 1) * envelope_size;
8113
8114            // Zero reserved fields.
8115            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8116
8117            // Safety:
8118            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8119            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8120            //   envelope_size bytes, there is always sufficient room.
8121            fidl::encoding::encode_in_envelope_optional::<Nat64PacketCounters, D>(
8122                self.unknown
8123                    .as_ref()
8124                    .map(<Nat64PacketCounters as fidl::encoding::ValueTypeMarker>::borrow),
8125                encoder,
8126                offset + cur_offset,
8127                depth,
8128            )?;
8129
8130            _prev_end_offset = cur_offset + envelope_size;
8131            if 2 > max_ordinal {
8132                return Ok(());
8133            }
8134
8135            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8136            // are envelope_size bytes.
8137            let cur_offset: usize = (2 - 1) * envelope_size;
8138
8139            // Zero reserved fields.
8140            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8141
8142            // Safety:
8143            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8144            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8145            //   envelope_size bytes, there is always sufficient room.
8146            fidl::encoding::encode_in_envelope_optional::<Nat64PacketCounters, D>(
8147                self.illegal_packet
8148                    .as_ref()
8149                    .map(<Nat64PacketCounters as fidl::encoding::ValueTypeMarker>::borrow),
8150                encoder,
8151                offset + cur_offset,
8152                depth,
8153            )?;
8154
8155            _prev_end_offset = cur_offset + envelope_size;
8156            if 3 > max_ordinal {
8157                return Ok(());
8158            }
8159
8160            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8161            // are envelope_size bytes.
8162            let cur_offset: usize = (3 - 1) * envelope_size;
8163
8164            // Zero reserved fields.
8165            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8166
8167            // Safety:
8168            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8169            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8170            //   envelope_size bytes, there is always sufficient room.
8171            fidl::encoding::encode_in_envelope_optional::<Nat64PacketCounters, D>(
8172                self.unsupported_protocol
8173                    .as_ref()
8174                    .map(<Nat64PacketCounters as fidl::encoding::ValueTypeMarker>::borrow),
8175                encoder,
8176                offset + cur_offset,
8177                depth,
8178            )?;
8179
8180            _prev_end_offset = cur_offset + envelope_size;
8181            if 4 > max_ordinal {
8182                return Ok(());
8183            }
8184
8185            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8186            // are envelope_size bytes.
8187            let cur_offset: usize = (4 - 1) * envelope_size;
8188
8189            // Zero reserved fields.
8190            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8191
8192            // Safety:
8193            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8194            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8195            //   envelope_size bytes, there is always sufficient room.
8196            fidl::encoding::encode_in_envelope_optional::<Nat64PacketCounters, D>(
8197                self.no_mapping
8198                    .as_ref()
8199                    .map(<Nat64PacketCounters as fidl::encoding::ValueTypeMarker>::borrow),
8200                encoder,
8201                offset + cur_offset,
8202                depth,
8203            )?;
8204
8205            _prev_end_offset = cur_offset + envelope_size;
8206
8207            Ok(())
8208        }
8209    }
8210
8211    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64ErrorCounters {
8212        #[inline(always)]
8213        fn new_empty() -> Self {
8214            Self::default()
8215        }
8216
8217        unsafe fn decode(
8218            &mut self,
8219            decoder: &mut fidl::encoding::Decoder<'_, D>,
8220            offset: usize,
8221            mut depth: fidl::encoding::Depth,
8222        ) -> fidl::Result<()> {
8223            decoder.debug_check_bounds::<Self>(offset);
8224            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8225                None => return Err(fidl::Error::NotNullable),
8226                Some(len) => len,
8227            };
8228            // Calling decoder.out_of_line_offset(0) is not allowed.
8229            if len == 0 {
8230                return Ok(());
8231            };
8232            depth.increment()?;
8233            let envelope_size = 8;
8234            let bytes_len = len * envelope_size;
8235            let offset = decoder.out_of_line_offset(bytes_len)?;
8236            // Decode the envelope for each type.
8237            let mut _next_ordinal_to_read = 0;
8238            let mut next_offset = offset;
8239            let end_offset = offset + bytes_len;
8240            _next_ordinal_to_read += 1;
8241            if next_offset >= end_offset {
8242                return Ok(());
8243            }
8244
8245            // Decode unknown envelopes for gaps in ordinals.
8246            while _next_ordinal_to_read < 1 {
8247                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8248                _next_ordinal_to_read += 1;
8249                next_offset += envelope_size;
8250            }
8251
8252            let next_out_of_line = decoder.next_out_of_line();
8253            let handles_before = decoder.remaining_handles();
8254            if let Some((inlined, num_bytes, num_handles)) =
8255                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8256            {
8257                let member_inline_size =
8258                    <Nat64PacketCounters as fidl::encoding::TypeMarker>::inline_size(
8259                        decoder.context,
8260                    );
8261                if inlined != (member_inline_size <= 4) {
8262                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8263                }
8264                let inner_offset;
8265                let mut inner_depth = depth.clone();
8266                if inlined {
8267                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8268                    inner_offset = next_offset;
8269                } else {
8270                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8271                    inner_depth.increment()?;
8272                }
8273                let val_ref =
8274                    self.unknown.get_or_insert_with(|| fidl::new_empty!(Nat64PacketCounters, D));
8275                fidl::decode!(Nat64PacketCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8276                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8277                {
8278                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8279                }
8280                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8281                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8282                }
8283            }
8284
8285            next_offset += envelope_size;
8286            _next_ordinal_to_read += 1;
8287            if next_offset >= end_offset {
8288                return Ok(());
8289            }
8290
8291            // Decode unknown envelopes for gaps in ordinals.
8292            while _next_ordinal_to_read < 2 {
8293                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8294                _next_ordinal_to_read += 1;
8295                next_offset += envelope_size;
8296            }
8297
8298            let next_out_of_line = decoder.next_out_of_line();
8299            let handles_before = decoder.remaining_handles();
8300            if let Some((inlined, num_bytes, num_handles)) =
8301                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8302            {
8303                let member_inline_size =
8304                    <Nat64PacketCounters as fidl::encoding::TypeMarker>::inline_size(
8305                        decoder.context,
8306                    );
8307                if inlined != (member_inline_size <= 4) {
8308                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8309                }
8310                let inner_offset;
8311                let mut inner_depth = depth.clone();
8312                if inlined {
8313                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8314                    inner_offset = next_offset;
8315                } else {
8316                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8317                    inner_depth.increment()?;
8318                }
8319                let val_ref = self
8320                    .illegal_packet
8321                    .get_or_insert_with(|| fidl::new_empty!(Nat64PacketCounters, D));
8322                fidl::decode!(Nat64PacketCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8323                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8324                {
8325                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8326                }
8327                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8328                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8329                }
8330            }
8331
8332            next_offset += envelope_size;
8333            _next_ordinal_to_read += 1;
8334            if next_offset >= end_offset {
8335                return Ok(());
8336            }
8337
8338            // Decode unknown envelopes for gaps in ordinals.
8339            while _next_ordinal_to_read < 3 {
8340                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8341                _next_ordinal_to_read += 1;
8342                next_offset += envelope_size;
8343            }
8344
8345            let next_out_of_line = decoder.next_out_of_line();
8346            let handles_before = decoder.remaining_handles();
8347            if let Some((inlined, num_bytes, num_handles)) =
8348                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8349            {
8350                let member_inline_size =
8351                    <Nat64PacketCounters as fidl::encoding::TypeMarker>::inline_size(
8352                        decoder.context,
8353                    );
8354                if inlined != (member_inline_size <= 4) {
8355                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8356                }
8357                let inner_offset;
8358                let mut inner_depth = depth.clone();
8359                if inlined {
8360                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8361                    inner_offset = next_offset;
8362                } else {
8363                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8364                    inner_depth.increment()?;
8365                }
8366                let val_ref = self
8367                    .unsupported_protocol
8368                    .get_or_insert_with(|| fidl::new_empty!(Nat64PacketCounters, D));
8369                fidl::decode!(Nat64PacketCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8370                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8371                {
8372                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8373                }
8374                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8375                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8376                }
8377            }
8378
8379            next_offset += envelope_size;
8380            _next_ordinal_to_read += 1;
8381            if next_offset >= end_offset {
8382                return Ok(());
8383            }
8384
8385            // Decode unknown envelopes for gaps in ordinals.
8386            while _next_ordinal_to_read < 4 {
8387                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8388                _next_ordinal_to_read += 1;
8389                next_offset += envelope_size;
8390            }
8391
8392            let next_out_of_line = decoder.next_out_of_line();
8393            let handles_before = decoder.remaining_handles();
8394            if let Some((inlined, num_bytes, num_handles)) =
8395                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8396            {
8397                let member_inline_size =
8398                    <Nat64PacketCounters as fidl::encoding::TypeMarker>::inline_size(
8399                        decoder.context,
8400                    );
8401                if inlined != (member_inline_size <= 4) {
8402                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8403                }
8404                let inner_offset;
8405                let mut inner_depth = depth.clone();
8406                if inlined {
8407                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8408                    inner_offset = next_offset;
8409                } else {
8410                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8411                    inner_depth.increment()?;
8412                }
8413                let val_ref =
8414                    self.no_mapping.get_or_insert_with(|| fidl::new_empty!(Nat64PacketCounters, D));
8415                fidl::decode!(Nat64PacketCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8416                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8417                {
8418                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8419                }
8420                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8421                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8422                }
8423            }
8424
8425            next_offset += envelope_size;
8426
8427            // Decode the remaining unknown envelopes.
8428            while next_offset < end_offset {
8429                _next_ordinal_to_read += 1;
8430                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8431                next_offset += envelope_size;
8432            }
8433
8434            Ok(())
8435        }
8436    }
8437
8438    impl Nat64Info {
8439        #[inline(always)]
8440        fn max_ordinal_present(&self) -> u64 {
8441            if let Some(_) = self.nat64_protocol_counters {
8442                return 4;
8443            }
8444            if let Some(_) = self.nat64_error_counters {
8445                return 3;
8446            }
8447            if let Some(_) = self.nat64_mappings {
8448                return 2;
8449            }
8450            if let Some(_) = self.nat64_state {
8451                return 1;
8452            }
8453            0
8454        }
8455    }
8456
8457    impl fidl::encoding::ValueTypeMarker for Nat64Info {
8458        type Borrowed<'a> = &'a Self;
8459        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8460            value
8461        }
8462    }
8463
8464    unsafe impl fidl::encoding::TypeMarker for Nat64Info {
8465        type Owned = Self;
8466
8467        #[inline(always)]
8468        fn inline_align(_context: fidl::encoding::Context) -> usize {
8469            8
8470        }
8471
8472        #[inline(always)]
8473        fn inline_size(_context: fidl::encoding::Context) -> usize {
8474            16
8475        }
8476    }
8477
8478    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64Info, D>
8479        for &Nat64Info
8480    {
8481        unsafe fn encode(
8482            self,
8483            encoder: &mut fidl::encoding::Encoder<'_, D>,
8484            offset: usize,
8485            mut depth: fidl::encoding::Depth,
8486        ) -> fidl::Result<()> {
8487            encoder.debug_check_bounds::<Nat64Info>(offset);
8488            // Vector header
8489            let max_ordinal: u64 = self.max_ordinal_present();
8490            encoder.write_num(max_ordinal, offset);
8491            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8492            // Calling encoder.out_of_line_offset(0) is not allowed.
8493            if max_ordinal == 0 {
8494                return Ok(());
8495            }
8496            depth.increment()?;
8497            let envelope_size = 8;
8498            let bytes_len = max_ordinal as usize * envelope_size;
8499            #[allow(unused_variables)]
8500            let offset = encoder.out_of_line_offset(bytes_len);
8501            let mut _prev_end_offset: usize = 0;
8502            if 1 > max_ordinal {
8503                return Ok(());
8504            }
8505
8506            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8507            // are envelope_size bytes.
8508            let cur_offset: usize = (1 - 1) * envelope_size;
8509
8510            // Zero reserved fields.
8511            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8512
8513            // Safety:
8514            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8515            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8516            //   envelope_size bytes, there is always sufficient room.
8517            fidl::encoding::encode_in_envelope_optional::<BorderRoutingNat64State, D>(
8518                self.nat64_state
8519                    .as_ref()
8520                    .map(<BorderRoutingNat64State as fidl::encoding::ValueTypeMarker>::borrow),
8521                encoder,
8522                offset + cur_offset,
8523                depth,
8524            )?;
8525
8526            _prev_end_offset = cur_offset + envelope_size;
8527            if 2 > max_ordinal {
8528                return Ok(());
8529            }
8530
8531            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8532            // are envelope_size bytes.
8533            let cur_offset: usize = (2 - 1) * envelope_size;
8534
8535            // Zero reserved fields.
8536            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8537
8538            // Safety:
8539            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8540            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8541            //   envelope_size bytes, there is always sufficient room.
8542            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<Nat64Mapping>, D>(
8543            self.nat64_mappings.as_ref().map(<fidl::encoding::UnboundedVector<Nat64Mapping> as fidl::encoding::ValueTypeMarker>::borrow),
8544            encoder, offset + cur_offset, depth
8545        )?;
8546
8547            _prev_end_offset = cur_offset + envelope_size;
8548            if 3 > max_ordinal {
8549                return Ok(());
8550            }
8551
8552            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8553            // are envelope_size bytes.
8554            let cur_offset: usize = (3 - 1) * envelope_size;
8555
8556            // Zero reserved fields.
8557            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8558
8559            // Safety:
8560            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8561            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8562            //   envelope_size bytes, there is always sufficient room.
8563            fidl::encoding::encode_in_envelope_optional::<Nat64ErrorCounters, D>(
8564                self.nat64_error_counters
8565                    .as_ref()
8566                    .map(<Nat64ErrorCounters as fidl::encoding::ValueTypeMarker>::borrow),
8567                encoder,
8568                offset + cur_offset,
8569                depth,
8570            )?;
8571
8572            _prev_end_offset = cur_offset + envelope_size;
8573            if 4 > max_ordinal {
8574                return Ok(());
8575            }
8576
8577            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8578            // are envelope_size bytes.
8579            let cur_offset: usize = (4 - 1) * envelope_size;
8580
8581            // Zero reserved fields.
8582            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8583
8584            // Safety:
8585            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8586            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8587            //   envelope_size bytes, there is always sufficient room.
8588            fidl::encoding::encode_in_envelope_optional::<Nat64ProtocolCounters, D>(
8589                self.nat64_protocol_counters
8590                    .as_ref()
8591                    .map(<Nat64ProtocolCounters as fidl::encoding::ValueTypeMarker>::borrow),
8592                encoder,
8593                offset + cur_offset,
8594                depth,
8595            )?;
8596
8597            _prev_end_offset = cur_offset + envelope_size;
8598
8599            Ok(())
8600        }
8601    }
8602
8603    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64Info {
8604        #[inline(always)]
8605        fn new_empty() -> Self {
8606            Self::default()
8607        }
8608
8609        unsafe fn decode(
8610            &mut self,
8611            decoder: &mut fidl::encoding::Decoder<'_, D>,
8612            offset: usize,
8613            mut depth: fidl::encoding::Depth,
8614        ) -> fidl::Result<()> {
8615            decoder.debug_check_bounds::<Self>(offset);
8616            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
8617                None => return Err(fidl::Error::NotNullable),
8618                Some(len) => len,
8619            };
8620            // Calling decoder.out_of_line_offset(0) is not allowed.
8621            if len == 0 {
8622                return Ok(());
8623            };
8624            depth.increment()?;
8625            let envelope_size = 8;
8626            let bytes_len = len * envelope_size;
8627            let offset = decoder.out_of_line_offset(bytes_len)?;
8628            // Decode the envelope for each type.
8629            let mut _next_ordinal_to_read = 0;
8630            let mut next_offset = offset;
8631            let end_offset = offset + bytes_len;
8632            _next_ordinal_to_read += 1;
8633            if next_offset >= end_offset {
8634                return Ok(());
8635            }
8636
8637            // Decode unknown envelopes for gaps in ordinals.
8638            while _next_ordinal_to_read < 1 {
8639                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8640                _next_ordinal_to_read += 1;
8641                next_offset += envelope_size;
8642            }
8643
8644            let next_out_of_line = decoder.next_out_of_line();
8645            let handles_before = decoder.remaining_handles();
8646            if let Some((inlined, num_bytes, num_handles)) =
8647                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8648            {
8649                let member_inline_size =
8650                    <BorderRoutingNat64State as fidl::encoding::TypeMarker>::inline_size(
8651                        decoder.context,
8652                    );
8653                if inlined != (member_inline_size <= 4) {
8654                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8655                }
8656                let inner_offset;
8657                let mut inner_depth = depth.clone();
8658                if inlined {
8659                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8660                    inner_offset = next_offset;
8661                } else {
8662                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8663                    inner_depth.increment()?;
8664                }
8665                let val_ref = self
8666                    .nat64_state
8667                    .get_or_insert_with(|| fidl::new_empty!(BorderRoutingNat64State, D));
8668                fidl::decode!(
8669                    BorderRoutingNat64State,
8670                    D,
8671                    val_ref,
8672                    decoder,
8673                    inner_offset,
8674                    inner_depth
8675                )?;
8676                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8677                {
8678                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8679                }
8680                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8681                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8682                }
8683            }
8684
8685            next_offset += envelope_size;
8686            _next_ordinal_to_read += 1;
8687            if next_offset >= end_offset {
8688                return Ok(());
8689            }
8690
8691            // Decode unknown envelopes for gaps in ordinals.
8692            while _next_ordinal_to_read < 2 {
8693                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8694                _next_ordinal_to_read += 1;
8695                next_offset += envelope_size;
8696            }
8697
8698            let next_out_of_line = decoder.next_out_of_line();
8699            let handles_before = decoder.remaining_handles();
8700            if let Some((inlined, num_bytes, num_handles)) =
8701                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8702            {
8703                let member_inline_size = <fidl::encoding::UnboundedVector<Nat64Mapping> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
8704                if inlined != (member_inline_size <= 4) {
8705                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8706                }
8707                let inner_offset;
8708                let mut inner_depth = depth.clone();
8709                if inlined {
8710                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8711                    inner_offset = next_offset;
8712                } else {
8713                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8714                    inner_depth.increment()?;
8715                }
8716                let val_ref = self.nat64_mappings.get_or_insert_with(|| {
8717                    fidl::new_empty!(fidl::encoding::UnboundedVector<Nat64Mapping>, D)
8718                });
8719                fidl::decode!(
8720                    fidl::encoding::UnboundedVector<Nat64Mapping>,
8721                    D,
8722                    val_ref,
8723                    decoder,
8724                    inner_offset,
8725                    inner_depth
8726                )?;
8727                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8728                {
8729                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8730                }
8731                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8732                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8733                }
8734            }
8735
8736            next_offset += envelope_size;
8737            _next_ordinal_to_read += 1;
8738            if next_offset >= end_offset {
8739                return Ok(());
8740            }
8741
8742            // Decode unknown envelopes for gaps in ordinals.
8743            while _next_ordinal_to_read < 3 {
8744                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8745                _next_ordinal_to_read += 1;
8746                next_offset += envelope_size;
8747            }
8748
8749            let next_out_of_line = decoder.next_out_of_line();
8750            let handles_before = decoder.remaining_handles();
8751            if let Some((inlined, num_bytes, num_handles)) =
8752                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8753            {
8754                let member_inline_size =
8755                    <Nat64ErrorCounters as fidl::encoding::TypeMarker>::inline_size(
8756                        decoder.context,
8757                    );
8758                if inlined != (member_inline_size <= 4) {
8759                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8760                }
8761                let inner_offset;
8762                let mut inner_depth = depth.clone();
8763                if inlined {
8764                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8765                    inner_offset = next_offset;
8766                } else {
8767                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8768                    inner_depth.increment()?;
8769                }
8770                let val_ref = self
8771                    .nat64_error_counters
8772                    .get_or_insert_with(|| fidl::new_empty!(Nat64ErrorCounters, D));
8773                fidl::decode!(Nat64ErrorCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
8774                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8775                {
8776                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8777                }
8778                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8779                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8780                }
8781            }
8782
8783            next_offset += envelope_size;
8784            _next_ordinal_to_read += 1;
8785            if next_offset >= end_offset {
8786                return Ok(());
8787            }
8788
8789            // Decode unknown envelopes for gaps in ordinals.
8790            while _next_ordinal_to_read < 4 {
8791                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8792                _next_ordinal_to_read += 1;
8793                next_offset += envelope_size;
8794            }
8795
8796            let next_out_of_line = decoder.next_out_of_line();
8797            let handles_before = decoder.remaining_handles();
8798            if let Some((inlined, num_bytes, num_handles)) =
8799                fidl::encoding::decode_envelope_header(decoder, next_offset)?
8800            {
8801                let member_inline_size =
8802                    <Nat64ProtocolCounters as fidl::encoding::TypeMarker>::inline_size(
8803                        decoder.context,
8804                    );
8805                if inlined != (member_inline_size <= 4) {
8806                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
8807                }
8808                let inner_offset;
8809                let mut inner_depth = depth.clone();
8810                if inlined {
8811                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
8812                    inner_offset = next_offset;
8813                } else {
8814                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
8815                    inner_depth.increment()?;
8816                }
8817                let val_ref = self
8818                    .nat64_protocol_counters
8819                    .get_or_insert_with(|| fidl::new_empty!(Nat64ProtocolCounters, D));
8820                fidl::decode!(
8821                    Nat64ProtocolCounters,
8822                    D,
8823                    val_ref,
8824                    decoder,
8825                    inner_offset,
8826                    inner_depth
8827                )?;
8828                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
8829                {
8830                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
8831                }
8832                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
8833                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
8834                }
8835            }
8836
8837            next_offset += envelope_size;
8838
8839            // Decode the remaining unknown envelopes.
8840            while next_offset < end_offset {
8841                _next_ordinal_to_read += 1;
8842                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
8843                next_offset += envelope_size;
8844            }
8845
8846            Ok(())
8847        }
8848    }
8849
8850    impl Nat64Mapping {
8851        #[inline(always)]
8852        fn max_ordinal_present(&self) -> u64 {
8853            if let Some(_) = self.counters {
8854                return 5;
8855            }
8856            if let Some(_) = self.remaining_time_ms {
8857                return 4;
8858            }
8859            if let Some(_) = self.ip6_addr {
8860                return 3;
8861            }
8862            if let Some(_) = self.ip4_addr {
8863                return 2;
8864            }
8865            if let Some(_) = self.mapping_id {
8866                return 1;
8867            }
8868            0
8869        }
8870    }
8871
8872    impl fidl::encoding::ValueTypeMarker for Nat64Mapping {
8873        type Borrowed<'a> = &'a Self;
8874        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
8875            value
8876        }
8877    }
8878
8879    unsafe impl fidl::encoding::TypeMarker for Nat64Mapping {
8880        type Owned = Self;
8881
8882        #[inline(always)]
8883        fn inline_align(_context: fidl::encoding::Context) -> usize {
8884            8
8885        }
8886
8887        #[inline(always)]
8888        fn inline_size(_context: fidl::encoding::Context) -> usize {
8889            16
8890        }
8891    }
8892
8893    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64Mapping, D>
8894        for &Nat64Mapping
8895    {
8896        unsafe fn encode(
8897            self,
8898            encoder: &mut fidl::encoding::Encoder<'_, D>,
8899            offset: usize,
8900            mut depth: fidl::encoding::Depth,
8901        ) -> fidl::Result<()> {
8902            encoder.debug_check_bounds::<Nat64Mapping>(offset);
8903            // Vector header
8904            let max_ordinal: u64 = self.max_ordinal_present();
8905            encoder.write_num(max_ordinal, offset);
8906            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
8907            // Calling encoder.out_of_line_offset(0) is not allowed.
8908            if max_ordinal == 0 {
8909                return Ok(());
8910            }
8911            depth.increment()?;
8912            let envelope_size = 8;
8913            let bytes_len = max_ordinal as usize * envelope_size;
8914            #[allow(unused_variables)]
8915            let offset = encoder.out_of_line_offset(bytes_len);
8916            let mut _prev_end_offset: usize = 0;
8917            if 1 > max_ordinal {
8918                return Ok(());
8919            }
8920
8921            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8922            // are envelope_size bytes.
8923            let cur_offset: usize = (1 - 1) * envelope_size;
8924
8925            // Zero reserved fields.
8926            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8927
8928            // Safety:
8929            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8930            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8931            //   envelope_size bytes, there is always sufficient room.
8932            fidl::encoding::encode_in_envelope_optional::<u64, D>(
8933                self.mapping_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
8934                encoder,
8935                offset + cur_offset,
8936                depth,
8937            )?;
8938
8939            _prev_end_offset = cur_offset + envelope_size;
8940            if 2 > max_ordinal {
8941                return Ok(());
8942            }
8943
8944            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8945            // are envelope_size bytes.
8946            let cur_offset: usize = (2 - 1) * envelope_size;
8947
8948            // Zero reserved fields.
8949            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8950
8951            // Safety:
8952            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8953            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8954            //   envelope_size bytes, there is always sufficient room.
8955            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8956            self.ip4_addr.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8957            encoder, offset + cur_offset, depth
8958        )?;
8959
8960            _prev_end_offset = cur_offset + envelope_size;
8961            if 3 > max_ordinal {
8962                return Ok(());
8963            }
8964
8965            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8966            // are envelope_size bytes.
8967            let cur_offset: usize = (3 - 1) * envelope_size;
8968
8969            // Zero reserved fields.
8970            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8971
8972            // Safety:
8973            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8974            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8975            //   envelope_size bytes, there is always sufficient room.
8976            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
8977            self.ip6_addr.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
8978            encoder, offset + cur_offset, depth
8979        )?;
8980
8981            _prev_end_offset = cur_offset + envelope_size;
8982            if 4 > max_ordinal {
8983                return Ok(());
8984            }
8985
8986            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
8987            // are envelope_size bytes.
8988            let cur_offset: usize = (4 - 1) * envelope_size;
8989
8990            // Zero reserved fields.
8991            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
8992
8993            // Safety:
8994            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
8995            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
8996            //   envelope_size bytes, there is always sufficient room.
8997            fidl::encoding::encode_in_envelope_optional::<u32, D>(
8998                self.remaining_time_ms
8999                    .as_ref()
9000                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
9001                encoder,
9002                offset + cur_offset,
9003                depth,
9004            )?;
9005
9006            _prev_end_offset = cur_offset + envelope_size;
9007            if 5 > max_ordinal {
9008                return Ok(());
9009            }
9010
9011            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9012            // are envelope_size bytes.
9013            let cur_offset: usize = (5 - 1) * envelope_size;
9014
9015            // Zero reserved fields.
9016            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9017
9018            // Safety:
9019            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9020            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9021            //   envelope_size bytes, there is always sufficient room.
9022            fidl::encoding::encode_in_envelope_optional::<Nat64ProtocolCounters, D>(
9023                self.counters
9024                    .as_ref()
9025                    .map(<Nat64ProtocolCounters as fidl::encoding::ValueTypeMarker>::borrow),
9026                encoder,
9027                offset + cur_offset,
9028                depth,
9029            )?;
9030
9031            _prev_end_offset = cur_offset + envelope_size;
9032
9033            Ok(())
9034        }
9035    }
9036
9037    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64Mapping {
9038        #[inline(always)]
9039        fn new_empty() -> Self {
9040            Self::default()
9041        }
9042
9043        unsafe fn decode(
9044            &mut self,
9045            decoder: &mut fidl::encoding::Decoder<'_, D>,
9046            offset: usize,
9047            mut depth: fidl::encoding::Depth,
9048        ) -> fidl::Result<()> {
9049            decoder.debug_check_bounds::<Self>(offset);
9050            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9051                None => return Err(fidl::Error::NotNullable),
9052                Some(len) => len,
9053            };
9054            // Calling decoder.out_of_line_offset(0) is not allowed.
9055            if len == 0 {
9056                return Ok(());
9057            };
9058            depth.increment()?;
9059            let envelope_size = 8;
9060            let bytes_len = len * envelope_size;
9061            let offset = decoder.out_of_line_offset(bytes_len)?;
9062            // Decode the envelope for each type.
9063            let mut _next_ordinal_to_read = 0;
9064            let mut next_offset = offset;
9065            let end_offset = offset + bytes_len;
9066            _next_ordinal_to_read += 1;
9067            if next_offset >= end_offset {
9068                return Ok(());
9069            }
9070
9071            // Decode unknown envelopes for gaps in ordinals.
9072            while _next_ordinal_to_read < 1 {
9073                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9074                _next_ordinal_to_read += 1;
9075                next_offset += envelope_size;
9076            }
9077
9078            let next_out_of_line = decoder.next_out_of_line();
9079            let handles_before = decoder.remaining_handles();
9080            if let Some((inlined, num_bytes, num_handles)) =
9081                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9082            {
9083                let member_inline_size =
9084                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9085                if inlined != (member_inline_size <= 4) {
9086                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9087                }
9088                let inner_offset;
9089                let mut inner_depth = depth.clone();
9090                if inlined {
9091                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9092                    inner_offset = next_offset;
9093                } else {
9094                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9095                    inner_depth.increment()?;
9096                }
9097                let val_ref = self.mapping_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
9098                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9099                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9100                {
9101                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9102                }
9103                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9104                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9105                }
9106            }
9107
9108            next_offset += envelope_size;
9109            _next_ordinal_to_read += 1;
9110            if next_offset >= end_offset {
9111                return Ok(());
9112            }
9113
9114            // Decode unknown envelopes for gaps in ordinals.
9115            while _next_ordinal_to_read < 2 {
9116                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9117                _next_ordinal_to_read += 1;
9118                next_offset += envelope_size;
9119            }
9120
9121            let next_out_of_line = decoder.next_out_of_line();
9122            let handles_before = decoder.remaining_handles();
9123            if let Some((inlined, num_bytes, num_handles)) =
9124                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9125            {
9126                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9127                if inlined != (member_inline_size <= 4) {
9128                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9129                }
9130                let inner_offset;
9131                let mut inner_depth = depth.clone();
9132                if inlined {
9133                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9134                    inner_offset = next_offset;
9135                } else {
9136                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9137                    inner_depth.increment()?;
9138                }
9139                let val_ref = self.ip4_addr.get_or_insert_with(|| {
9140                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
9141                });
9142                fidl::decode!(
9143                    fidl::encoding::UnboundedVector<u8>,
9144                    D,
9145                    val_ref,
9146                    decoder,
9147                    inner_offset,
9148                    inner_depth
9149                )?;
9150                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9151                {
9152                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9153                }
9154                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9155                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9156                }
9157            }
9158
9159            next_offset += envelope_size;
9160            _next_ordinal_to_read += 1;
9161            if next_offset >= end_offset {
9162                return Ok(());
9163            }
9164
9165            // Decode unknown envelopes for gaps in ordinals.
9166            while _next_ordinal_to_read < 3 {
9167                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9168                _next_ordinal_to_read += 1;
9169                next_offset += envelope_size;
9170            }
9171
9172            let next_out_of_line = decoder.next_out_of_line();
9173            let handles_before = decoder.remaining_handles();
9174            if let Some((inlined, num_bytes, num_handles)) =
9175                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9176            {
9177                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9178                if inlined != (member_inline_size <= 4) {
9179                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9180                }
9181                let inner_offset;
9182                let mut inner_depth = depth.clone();
9183                if inlined {
9184                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9185                    inner_offset = next_offset;
9186                } else {
9187                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9188                    inner_depth.increment()?;
9189                }
9190                let val_ref = self.ip6_addr.get_or_insert_with(|| {
9191                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
9192                });
9193                fidl::decode!(
9194                    fidl::encoding::UnboundedVector<u8>,
9195                    D,
9196                    val_ref,
9197                    decoder,
9198                    inner_offset,
9199                    inner_depth
9200                )?;
9201                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9202                {
9203                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9204                }
9205                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9206                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9207                }
9208            }
9209
9210            next_offset += envelope_size;
9211            _next_ordinal_to_read += 1;
9212            if next_offset >= end_offset {
9213                return Ok(());
9214            }
9215
9216            // Decode unknown envelopes for gaps in ordinals.
9217            while _next_ordinal_to_read < 4 {
9218                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9219                _next_ordinal_to_read += 1;
9220                next_offset += envelope_size;
9221            }
9222
9223            let next_out_of_line = decoder.next_out_of_line();
9224            let handles_before = decoder.remaining_handles();
9225            if let Some((inlined, num_bytes, num_handles)) =
9226                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9227            {
9228                let member_inline_size =
9229                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9230                if inlined != (member_inline_size <= 4) {
9231                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9232                }
9233                let inner_offset;
9234                let mut inner_depth = depth.clone();
9235                if inlined {
9236                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9237                    inner_offset = next_offset;
9238                } else {
9239                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9240                    inner_depth.increment()?;
9241                }
9242                let val_ref =
9243                    self.remaining_time_ms.get_or_insert_with(|| fidl::new_empty!(u32, D));
9244                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
9245                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9246                {
9247                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9248                }
9249                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9250                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9251                }
9252            }
9253
9254            next_offset += envelope_size;
9255            _next_ordinal_to_read += 1;
9256            if next_offset >= end_offset {
9257                return Ok(());
9258            }
9259
9260            // Decode unknown envelopes for gaps in ordinals.
9261            while _next_ordinal_to_read < 5 {
9262                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9263                _next_ordinal_to_read += 1;
9264                next_offset += envelope_size;
9265            }
9266
9267            let next_out_of_line = decoder.next_out_of_line();
9268            let handles_before = decoder.remaining_handles();
9269            if let Some((inlined, num_bytes, num_handles)) =
9270                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9271            {
9272                let member_inline_size =
9273                    <Nat64ProtocolCounters as fidl::encoding::TypeMarker>::inline_size(
9274                        decoder.context,
9275                    );
9276                if inlined != (member_inline_size <= 4) {
9277                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9278                }
9279                let inner_offset;
9280                let mut inner_depth = depth.clone();
9281                if inlined {
9282                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9283                    inner_offset = next_offset;
9284                } else {
9285                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9286                    inner_depth.increment()?;
9287                }
9288                let val_ref =
9289                    self.counters.get_or_insert_with(|| fidl::new_empty!(Nat64ProtocolCounters, D));
9290                fidl::decode!(
9291                    Nat64ProtocolCounters,
9292                    D,
9293                    val_ref,
9294                    decoder,
9295                    inner_offset,
9296                    inner_depth
9297                )?;
9298                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9299                {
9300                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9301                }
9302                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9303                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9304                }
9305            }
9306
9307            next_offset += envelope_size;
9308
9309            // Decode the remaining unknown envelopes.
9310            while next_offset < end_offset {
9311                _next_ordinal_to_read += 1;
9312                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9313                next_offset += envelope_size;
9314            }
9315
9316            Ok(())
9317        }
9318    }
9319
9320    impl Nat64PacketCounters {
9321        #[inline(always)]
9322        fn max_ordinal_present(&self) -> u64 {
9323            if let Some(_) = self.ipv6_to_ipv4_packets {
9324                return 2;
9325            }
9326            if let Some(_) = self.ipv4_to_ipv6_packets {
9327                return 1;
9328            }
9329            0
9330        }
9331    }
9332
9333    impl fidl::encoding::ValueTypeMarker for Nat64PacketCounters {
9334        type Borrowed<'a> = &'a Self;
9335        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9336            value
9337        }
9338    }
9339
9340    unsafe impl fidl::encoding::TypeMarker for Nat64PacketCounters {
9341        type Owned = Self;
9342
9343        #[inline(always)]
9344        fn inline_align(_context: fidl::encoding::Context) -> usize {
9345            8
9346        }
9347
9348        #[inline(always)]
9349        fn inline_size(_context: fidl::encoding::Context) -> usize {
9350            16
9351        }
9352    }
9353
9354    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64PacketCounters, D>
9355        for &Nat64PacketCounters
9356    {
9357        unsafe fn encode(
9358            self,
9359            encoder: &mut fidl::encoding::Encoder<'_, D>,
9360            offset: usize,
9361            mut depth: fidl::encoding::Depth,
9362        ) -> fidl::Result<()> {
9363            encoder.debug_check_bounds::<Nat64PacketCounters>(offset);
9364            // Vector header
9365            let max_ordinal: u64 = self.max_ordinal_present();
9366            encoder.write_num(max_ordinal, offset);
9367            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9368            // Calling encoder.out_of_line_offset(0) is not allowed.
9369            if max_ordinal == 0 {
9370                return Ok(());
9371            }
9372            depth.increment()?;
9373            let envelope_size = 8;
9374            let bytes_len = max_ordinal as usize * envelope_size;
9375            #[allow(unused_variables)]
9376            let offset = encoder.out_of_line_offset(bytes_len);
9377            let mut _prev_end_offset: usize = 0;
9378            if 1 > max_ordinal {
9379                return Ok(());
9380            }
9381
9382            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9383            // are envelope_size bytes.
9384            let cur_offset: usize = (1 - 1) * envelope_size;
9385
9386            // Zero reserved fields.
9387            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9388
9389            // Safety:
9390            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9391            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9392            //   envelope_size bytes, there is always sufficient room.
9393            fidl::encoding::encode_in_envelope_optional::<u64, D>(
9394                self.ipv4_to_ipv6_packets
9395                    .as_ref()
9396                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9397                encoder,
9398                offset + cur_offset,
9399                depth,
9400            )?;
9401
9402            _prev_end_offset = cur_offset + envelope_size;
9403            if 2 > max_ordinal {
9404                return Ok(());
9405            }
9406
9407            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9408            // are envelope_size bytes.
9409            let cur_offset: usize = (2 - 1) * envelope_size;
9410
9411            // Zero reserved fields.
9412            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9413
9414            // Safety:
9415            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9416            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9417            //   envelope_size bytes, there is always sufficient room.
9418            fidl::encoding::encode_in_envelope_optional::<u64, D>(
9419                self.ipv6_to_ipv4_packets
9420                    .as_ref()
9421                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
9422                encoder,
9423                offset + cur_offset,
9424                depth,
9425            )?;
9426
9427            _prev_end_offset = cur_offset + envelope_size;
9428
9429            Ok(())
9430        }
9431    }
9432
9433    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64PacketCounters {
9434        #[inline(always)]
9435        fn new_empty() -> Self {
9436            Self::default()
9437        }
9438
9439        unsafe fn decode(
9440            &mut self,
9441            decoder: &mut fidl::encoding::Decoder<'_, D>,
9442            offset: usize,
9443            mut depth: fidl::encoding::Depth,
9444        ) -> fidl::Result<()> {
9445            decoder.debug_check_bounds::<Self>(offset);
9446            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9447                None => return Err(fidl::Error::NotNullable),
9448                Some(len) => len,
9449            };
9450            // Calling decoder.out_of_line_offset(0) is not allowed.
9451            if len == 0 {
9452                return Ok(());
9453            };
9454            depth.increment()?;
9455            let envelope_size = 8;
9456            let bytes_len = len * envelope_size;
9457            let offset = decoder.out_of_line_offset(bytes_len)?;
9458            // Decode the envelope for each type.
9459            let mut _next_ordinal_to_read = 0;
9460            let mut next_offset = offset;
9461            let end_offset = offset + bytes_len;
9462            _next_ordinal_to_read += 1;
9463            if next_offset >= end_offset {
9464                return Ok(());
9465            }
9466
9467            // Decode unknown envelopes for gaps in ordinals.
9468            while _next_ordinal_to_read < 1 {
9469                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9470                _next_ordinal_to_read += 1;
9471                next_offset += envelope_size;
9472            }
9473
9474            let next_out_of_line = decoder.next_out_of_line();
9475            let handles_before = decoder.remaining_handles();
9476            if let Some((inlined, num_bytes, num_handles)) =
9477                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9478            {
9479                let member_inline_size =
9480                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9481                if inlined != (member_inline_size <= 4) {
9482                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9483                }
9484                let inner_offset;
9485                let mut inner_depth = depth.clone();
9486                if inlined {
9487                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9488                    inner_offset = next_offset;
9489                } else {
9490                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9491                    inner_depth.increment()?;
9492                }
9493                let val_ref =
9494                    self.ipv4_to_ipv6_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
9495                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9496                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9497                {
9498                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9499                }
9500                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9501                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9502                }
9503            }
9504
9505            next_offset += envelope_size;
9506            _next_ordinal_to_read += 1;
9507            if next_offset >= end_offset {
9508                return Ok(());
9509            }
9510
9511            // Decode unknown envelopes for gaps in ordinals.
9512            while _next_ordinal_to_read < 2 {
9513                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9514                _next_ordinal_to_read += 1;
9515                next_offset += envelope_size;
9516            }
9517
9518            let next_out_of_line = decoder.next_out_of_line();
9519            let handles_before = decoder.remaining_handles();
9520            if let Some((inlined, num_bytes, num_handles)) =
9521                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9522            {
9523                let member_inline_size =
9524                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
9525                if inlined != (member_inline_size <= 4) {
9526                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9527                }
9528                let inner_offset;
9529                let mut inner_depth = depth.clone();
9530                if inlined {
9531                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9532                    inner_offset = next_offset;
9533                } else {
9534                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9535                    inner_depth.increment()?;
9536                }
9537                let val_ref =
9538                    self.ipv6_to_ipv4_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
9539                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
9540                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9541                {
9542                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9543                }
9544                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9545                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9546                }
9547            }
9548
9549            next_offset += envelope_size;
9550
9551            // Decode the remaining unknown envelopes.
9552            while next_offset < end_offset {
9553                _next_ordinal_to_read += 1;
9554                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9555                next_offset += envelope_size;
9556            }
9557
9558            Ok(())
9559        }
9560    }
9561
9562    impl Nat64ProtocolCounters {
9563        #[inline(always)]
9564        fn max_ordinal_present(&self) -> u64 {
9565            if let Some(_) = self.total {
9566                return 4;
9567            }
9568            if let Some(_) = self.icmp {
9569                return 3;
9570            }
9571            if let Some(_) = self.udp {
9572                return 2;
9573            }
9574            if let Some(_) = self.tcp {
9575                return 1;
9576            }
9577            0
9578        }
9579    }
9580
9581    impl fidl::encoding::ValueTypeMarker for Nat64ProtocolCounters {
9582        type Borrowed<'a> = &'a Self;
9583        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
9584            value
9585        }
9586    }
9587
9588    unsafe impl fidl::encoding::TypeMarker for Nat64ProtocolCounters {
9589        type Owned = Self;
9590
9591        #[inline(always)]
9592        fn inline_align(_context: fidl::encoding::Context) -> usize {
9593            8
9594        }
9595
9596        #[inline(always)]
9597        fn inline_size(_context: fidl::encoding::Context) -> usize {
9598            16
9599        }
9600    }
9601
9602    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64ProtocolCounters, D>
9603        for &Nat64ProtocolCounters
9604    {
9605        unsafe fn encode(
9606            self,
9607            encoder: &mut fidl::encoding::Encoder<'_, D>,
9608            offset: usize,
9609            mut depth: fidl::encoding::Depth,
9610        ) -> fidl::Result<()> {
9611            encoder.debug_check_bounds::<Nat64ProtocolCounters>(offset);
9612            // Vector header
9613            let max_ordinal: u64 = self.max_ordinal_present();
9614            encoder.write_num(max_ordinal, offset);
9615            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
9616            // Calling encoder.out_of_line_offset(0) is not allowed.
9617            if max_ordinal == 0 {
9618                return Ok(());
9619            }
9620            depth.increment()?;
9621            let envelope_size = 8;
9622            let bytes_len = max_ordinal as usize * envelope_size;
9623            #[allow(unused_variables)]
9624            let offset = encoder.out_of_line_offset(bytes_len);
9625            let mut _prev_end_offset: usize = 0;
9626            if 1 > max_ordinal {
9627                return Ok(());
9628            }
9629
9630            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9631            // are envelope_size bytes.
9632            let cur_offset: usize = (1 - 1) * envelope_size;
9633
9634            // Zero reserved fields.
9635            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9636
9637            // Safety:
9638            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9639            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9640            //   envelope_size bytes, there is always sufficient room.
9641            fidl::encoding::encode_in_envelope_optional::<Nat64TrafficCounters, D>(
9642                self.tcp
9643                    .as_ref()
9644                    .map(<Nat64TrafficCounters as fidl::encoding::ValueTypeMarker>::borrow),
9645                encoder,
9646                offset + cur_offset,
9647                depth,
9648            )?;
9649
9650            _prev_end_offset = cur_offset + envelope_size;
9651            if 2 > max_ordinal {
9652                return Ok(());
9653            }
9654
9655            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9656            // are envelope_size bytes.
9657            let cur_offset: usize = (2 - 1) * envelope_size;
9658
9659            // Zero reserved fields.
9660            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9661
9662            // Safety:
9663            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9664            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9665            //   envelope_size bytes, there is always sufficient room.
9666            fidl::encoding::encode_in_envelope_optional::<Nat64TrafficCounters, D>(
9667                self.udp
9668                    .as_ref()
9669                    .map(<Nat64TrafficCounters as fidl::encoding::ValueTypeMarker>::borrow),
9670                encoder,
9671                offset + cur_offset,
9672                depth,
9673            )?;
9674
9675            _prev_end_offset = cur_offset + envelope_size;
9676            if 3 > max_ordinal {
9677                return Ok(());
9678            }
9679
9680            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9681            // are envelope_size bytes.
9682            let cur_offset: usize = (3 - 1) * envelope_size;
9683
9684            // Zero reserved fields.
9685            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9686
9687            // Safety:
9688            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9689            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9690            //   envelope_size bytes, there is always sufficient room.
9691            fidl::encoding::encode_in_envelope_optional::<Nat64TrafficCounters, D>(
9692                self.icmp
9693                    .as_ref()
9694                    .map(<Nat64TrafficCounters as fidl::encoding::ValueTypeMarker>::borrow),
9695                encoder,
9696                offset + cur_offset,
9697                depth,
9698            )?;
9699
9700            _prev_end_offset = cur_offset + envelope_size;
9701            if 4 > max_ordinal {
9702                return Ok(());
9703            }
9704
9705            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
9706            // are envelope_size bytes.
9707            let cur_offset: usize = (4 - 1) * envelope_size;
9708
9709            // Zero reserved fields.
9710            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
9711
9712            // Safety:
9713            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
9714            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
9715            //   envelope_size bytes, there is always sufficient room.
9716            fidl::encoding::encode_in_envelope_optional::<Nat64TrafficCounters, D>(
9717                self.total
9718                    .as_ref()
9719                    .map(<Nat64TrafficCounters as fidl::encoding::ValueTypeMarker>::borrow),
9720                encoder,
9721                offset + cur_offset,
9722                depth,
9723            )?;
9724
9725            _prev_end_offset = cur_offset + envelope_size;
9726
9727            Ok(())
9728        }
9729    }
9730
9731    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64ProtocolCounters {
9732        #[inline(always)]
9733        fn new_empty() -> Self {
9734            Self::default()
9735        }
9736
9737        unsafe fn decode(
9738            &mut self,
9739            decoder: &mut fidl::encoding::Decoder<'_, D>,
9740            offset: usize,
9741            mut depth: fidl::encoding::Depth,
9742        ) -> fidl::Result<()> {
9743            decoder.debug_check_bounds::<Self>(offset);
9744            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
9745                None => return Err(fidl::Error::NotNullable),
9746                Some(len) => len,
9747            };
9748            // Calling decoder.out_of_line_offset(0) is not allowed.
9749            if len == 0 {
9750                return Ok(());
9751            };
9752            depth.increment()?;
9753            let envelope_size = 8;
9754            let bytes_len = len * envelope_size;
9755            let offset = decoder.out_of_line_offset(bytes_len)?;
9756            // Decode the envelope for each type.
9757            let mut _next_ordinal_to_read = 0;
9758            let mut next_offset = offset;
9759            let end_offset = offset + bytes_len;
9760            _next_ordinal_to_read += 1;
9761            if next_offset >= end_offset {
9762                return Ok(());
9763            }
9764
9765            // Decode unknown envelopes for gaps in ordinals.
9766            while _next_ordinal_to_read < 1 {
9767                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9768                _next_ordinal_to_read += 1;
9769                next_offset += envelope_size;
9770            }
9771
9772            let next_out_of_line = decoder.next_out_of_line();
9773            let handles_before = decoder.remaining_handles();
9774            if let Some((inlined, num_bytes, num_handles)) =
9775                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9776            {
9777                let member_inline_size =
9778                    <Nat64TrafficCounters as fidl::encoding::TypeMarker>::inline_size(
9779                        decoder.context,
9780                    );
9781                if inlined != (member_inline_size <= 4) {
9782                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9783                }
9784                let inner_offset;
9785                let mut inner_depth = depth.clone();
9786                if inlined {
9787                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9788                    inner_offset = next_offset;
9789                } else {
9790                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9791                    inner_depth.increment()?;
9792                }
9793                let val_ref =
9794                    self.tcp.get_or_insert_with(|| fidl::new_empty!(Nat64TrafficCounters, D));
9795                fidl::decode!(
9796                    Nat64TrafficCounters,
9797                    D,
9798                    val_ref,
9799                    decoder,
9800                    inner_offset,
9801                    inner_depth
9802                )?;
9803                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9804                {
9805                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9806                }
9807                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9808                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9809                }
9810            }
9811
9812            next_offset += envelope_size;
9813            _next_ordinal_to_read += 1;
9814            if next_offset >= end_offset {
9815                return Ok(());
9816            }
9817
9818            // Decode unknown envelopes for gaps in ordinals.
9819            while _next_ordinal_to_read < 2 {
9820                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9821                _next_ordinal_to_read += 1;
9822                next_offset += envelope_size;
9823            }
9824
9825            let next_out_of_line = decoder.next_out_of_line();
9826            let handles_before = decoder.remaining_handles();
9827            if let Some((inlined, num_bytes, num_handles)) =
9828                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9829            {
9830                let member_inline_size =
9831                    <Nat64TrafficCounters as fidl::encoding::TypeMarker>::inline_size(
9832                        decoder.context,
9833                    );
9834                if inlined != (member_inline_size <= 4) {
9835                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9836                }
9837                let inner_offset;
9838                let mut inner_depth = depth.clone();
9839                if inlined {
9840                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9841                    inner_offset = next_offset;
9842                } else {
9843                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9844                    inner_depth.increment()?;
9845                }
9846                let val_ref =
9847                    self.udp.get_or_insert_with(|| fidl::new_empty!(Nat64TrafficCounters, D));
9848                fidl::decode!(
9849                    Nat64TrafficCounters,
9850                    D,
9851                    val_ref,
9852                    decoder,
9853                    inner_offset,
9854                    inner_depth
9855                )?;
9856                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9857                {
9858                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9859                }
9860                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9861                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9862                }
9863            }
9864
9865            next_offset += envelope_size;
9866            _next_ordinal_to_read += 1;
9867            if next_offset >= end_offset {
9868                return Ok(());
9869            }
9870
9871            // Decode unknown envelopes for gaps in ordinals.
9872            while _next_ordinal_to_read < 3 {
9873                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9874                _next_ordinal_to_read += 1;
9875                next_offset += envelope_size;
9876            }
9877
9878            let next_out_of_line = decoder.next_out_of_line();
9879            let handles_before = decoder.remaining_handles();
9880            if let Some((inlined, num_bytes, num_handles)) =
9881                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9882            {
9883                let member_inline_size =
9884                    <Nat64TrafficCounters as fidl::encoding::TypeMarker>::inline_size(
9885                        decoder.context,
9886                    );
9887                if inlined != (member_inline_size <= 4) {
9888                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9889                }
9890                let inner_offset;
9891                let mut inner_depth = depth.clone();
9892                if inlined {
9893                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9894                    inner_offset = next_offset;
9895                } else {
9896                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9897                    inner_depth.increment()?;
9898                }
9899                let val_ref =
9900                    self.icmp.get_or_insert_with(|| fidl::new_empty!(Nat64TrafficCounters, D));
9901                fidl::decode!(
9902                    Nat64TrafficCounters,
9903                    D,
9904                    val_ref,
9905                    decoder,
9906                    inner_offset,
9907                    inner_depth
9908                )?;
9909                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9910                {
9911                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9912                }
9913                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9914                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9915                }
9916            }
9917
9918            next_offset += envelope_size;
9919            _next_ordinal_to_read += 1;
9920            if next_offset >= end_offset {
9921                return Ok(());
9922            }
9923
9924            // Decode unknown envelopes for gaps in ordinals.
9925            while _next_ordinal_to_read < 4 {
9926                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9927                _next_ordinal_to_read += 1;
9928                next_offset += envelope_size;
9929            }
9930
9931            let next_out_of_line = decoder.next_out_of_line();
9932            let handles_before = decoder.remaining_handles();
9933            if let Some((inlined, num_bytes, num_handles)) =
9934                fidl::encoding::decode_envelope_header(decoder, next_offset)?
9935            {
9936                let member_inline_size =
9937                    <Nat64TrafficCounters as fidl::encoding::TypeMarker>::inline_size(
9938                        decoder.context,
9939                    );
9940                if inlined != (member_inline_size <= 4) {
9941                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
9942                }
9943                let inner_offset;
9944                let mut inner_depth = depth.clone();
9945                if inlined {
9946                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
9947                    inner_offset = next_offset;
9948                } else {
9949                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
9950                    inner_depth.increment()?;
9951                }
9952                let val_ref =
9953                    self.total.get_or_insert_with(|| fidl::new_empty!(Nat64TrafficCounters, D));
9954                fidl::decode!(
9955                    Nat64TrafficCounters,
9956                    D,
9957                    val_ref,
9958                    decoder,
9959                    inner_offset,
9960                    inner_depth
9961                )?;
9962                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
9963                {
9964                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
9965                }
9966                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
9967                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
9968                }
9969            }
9970
9971            next_offset += envelope_size;
9972
9973            // Decode the remaining unknown envelopes.
9974            while next_offset < end_offset {
9975                _next_ordinal_to_read += 1;
9976                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
9977                next_offset += envelope_size;
9978            }
9979
9980            Ok(())
9981        }
9982    }
9983
9984    impl Nat64TrafficCounters {
9985        #[inline(always)]
9986        fn max_ordinal_present(&self) -> u64 {
9987            if let Some(_) = self.ipv6_to_ipv4_bytes {
9988                return 4;
9989            }
9990            if let Some(_) = self.ipv6_to_ipv4_packets {
9991                return 3;
9992            }
9993            if let Some(_) = self.ipv4_to_ipv6_bytes {
9994                return 2;
9995            }
9996            if let Some(_) = self.ipv4_to_ipv6_packets {
9997                return 1;
9998            }
9999            0
10000        }
10001    }
10002
10003    impl fidl::encoding::ValueTypeMarker for Nat64TrafficCounters {
10004        type Borrowed<'a> = &'a Self;
10005        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10006            value
10007        }
10008    }
10009
10010    unsafe impl fidl::encoding::TypeMarker for Nat64TrafficCounters {
10011        type Owned = Self;
10012
10013        #[inline(always)]
10014        fn inline_align(_context: fidl::encoding::Context) -> usize {
10015            8
10016        }
10017
10018        #[inline(always)]
10019        fn inline_size(_context: fidl::encoding::Context) -> usize {
10020            16
10021        }
10022    }
10023
10024    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Nat64TrafficCounters, D>
10025        for &Nat64TrafficCounters
10026    {
10027        unsafe fn encode(
10028            self,
10029            encoder: &mut fidl::encoding::Encoder<'_, D>,
10030            offset: usize,
10031            mut depth: fidl::encoding::Depth,
10032        ) -> fidl::Result<()> {
10033            encoder.debug_check_bounds::<Nat64TrafficCounters>(offset);
10034            // Vector header
10035            let max_ordinal: u64 = self.max_ordinal_present();
10036            encoder.write_num(max_ordinal, offset);
10037            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10038            // Calling encoder.out_of_line_offset(0) is not allowed.
10039            if max_ordinal == 0 {
10040                return Ok(());
10041            }
10042            depth.increment()?;
10043            let envelope_size = 8;
10044            let bytes_len = max_ordinal as usize * envelope_size;
10045            #[allow(unused_variables)]
10046            let offset = encoder.out_of_line_offset(bytes_len);
10047            let mut _prev_end_offset: usize = 0;
10048            if 1 > max_ordinal {
10049                return Ok(());
10050            }
10051
10052            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10053            // are envelope_size bytes.
10054            let cur_offset: usize = (1 - 1) * envelope_size;
10055
10056            // Zero reserved fields.
10057            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10058
10059            // Safety:
10060            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10061            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10062            //   envelope_size bytes, there is always sufficient room.
10063            fidl::encoding::encode_in_envelope_optional::<u64, D>(
10064                self.ipv4_to_ipv6_packets
10065                    .as_ref()
10066                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10067                encoder,
10068                offset + cur_offset,
10069                depth,
10070            )?;
10071
10072            _prev_end_offset = cur_offset + envelope_size;
10073            if 2 > max_ordinal {
10074                return Ok(());
10075            }
10076
10077            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10078            // are envelope_size bytes.
10079            let cur_offset: usize = (2 - 1) * envelope_size;
10080
10081            // Zero reserved fields.
10082            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10083
10084            // Safety:
10085            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10086            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10087            //   envelope_size bytes, there is always sufficient room.
10088            fidl::encoding::encode_in_envelope_optional::<u64, D>(
10089                self.ipv4_to_ipv6_bytes
10090                    .as_ref()
10091                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10092                encoder,
10093                offset + cur_offset,
10094                depth,
10095            )?;
10096
10097            _prev_end_offset = cur_offset + envelope_size;
10098            if 3 > max_ordinal {
10099                return Ok(());
10100            }
10101
10102            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10103            // are envelope_size bytes.
10104            let cur_offset: usize = (3 - 1) * envelope_size;
10105
10106            // Zero reserved fields.
10107            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10108
10109            // Safety:
10110            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10111            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10112            //   envelope_size bytes, there is always sufficient room.
10113            fidl::encoding::encode_in_envelope_optional::<u64, D>(
10114                self.ipv6_to_ipv4_packets
10115                    .as_ref()
10116                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10117                encoder,
10118                offset + cur_offset,
10119                depth,
10120            )?;
10121
10122            _prev_end_offset = cur_offset + envelope_size;
10123            if 4 > max_ordinal {
10124                return Ok(());
10125            }
10126
10127            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10128            // are envelope_size bytes.
10129            let cur_offset: usize = (4 - 1) * envelope_size;
10130
10131            // Zero reserved fields.
10132            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10133
10134            // Safety:
10135            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10136            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10137            //   envelope_size bytes, there is always sufficient room.
10138            fidl::encoding::encode_in_envelope_optional::<u64, D>(
10139                self.ipv6_to_ipv4_bytes
10140                    .as_ref()
10141                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
10142                encoder,
10143                offset + cur_offset,
10144                depth,
10145            )?;
10146
10147            _prev_end_offset = cur_offset + envelope_size;
10148
10149            Ok(())
10150        }
10151    }
10152
10153    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Nat64TrafficCounters {
10154        #[inline(always)]
10155        fn new_empty() -> Self {
10156            Self::default()
10157        }
10158
10159        unsafe fn decode(
10160            &mut self,
10161            decoder: &mut fidl::encoding::Decoder<'_, D>,
10162            offset: usize,
10163            mut depth: fidl::encoding::Depth,
10164        ) -> fidl::Result<()> {
10165            decoder.debug_check_bounds::<Self>(offset);
10166            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10167                None => return Err(fidl::Error::NotNullable),
10168                Some(len) => len,
10169            };
10170            // Calling decoder.out_of_line_offset(0) is not allowed.
10171            if len == 0 {
10172                return Ok(());
10173            };
10174            depth.increment()?;
10175            let envelope_size = 8;
10176            let bytes_len = len * envelope_size;
10177            let offset = decoder.out_of_line_offset(bytes_len)?;
10178            // Decode the envelope for each type.
10179            let mut _next_ordinal_to_read = 0;
10180            let mut next_offset = offset;
10181            let end_offset = offset + bytes_len;
10182            _next_ordinal_to_read += 1;
10183            if next_offset >= end_offset {
10184                return Ok(());
10185            }
10186
10187            // Decode unknown envelopes for gaps in ordinals.
10188            while _next_ordinal_to_read < 1 {
10189                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10190                _next_ordinal_to_read += 1;
10191                next_offset += envelope_size;
10192            }
10193
10194            let next_out_of_line = decoder.next_out_of_line();
10195            let handles_before = decoder.remaining_handles();
10196            if let Some((inlined, num_bytes, num_handles)) =
10197                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10198            {
10199                let member_inline_size =
10200                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10201                if inlined != (member_inline_size <= 4) {
10202                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10203                }
10204                let inner_offset;
10205                let mut inner_depth = depth.clone();
10206                if inlined {
10207                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10208                    inner_offset = next_offset;
10209                } else {
10210                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10211                    inner_depth.increment()?;
10212                }
10213                let val_ref =
10214                    self.ipv4_to_ipv6_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
10215                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10216                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10217                {
10218                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10219                }
10220                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10221                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10222                }
10223            }
10224
10225            next_offset += envelope_size;
10226            _next_ordinal_to_read += 1;
10227            if next_offset >= end_offset {
10228                return Ok(());
10229            }
10230
10231            // Decode unknown envelopes for gaps in ordinals.
10232            while _next_ordinal_to_read < 2 {
10233                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10234                _next_ordinal_to_read += 1;
10235                next_offset += envelope_size;
10236            }
10237
10238            let next_out_of_line = decoder.next_out_of_line();
10239            let handles_before = decoder.remaining_handles();
10240            if let Some((inlined, num_bytes, num_handles)) =
10241                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10242            {
10243                let member_inline_size =
10244                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10245                if inlined != (member_inline_size <= 4) {
10246                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10247                }
10248                let inner_offset;
10249                let mut inner_depth = depth.clone();
10250                if inlined {
10251                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10252                    inner_offset = next_offset;
10253                } else {
10254                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10255                    inner_depth.increment()?;
10256                }
10257                let val_ref =
10258                    self.ipv4_to_ipv6_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
10259                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10260                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10261                {
10262                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10263                }
10264                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10265                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10266                }
10267            }
10268
10269            next_offset += envelope_size;
10270            _next_ordinal_to_read += 1;
10271            if next_offset >= end_offset {
10272                return Ok(());
10273            }
10274
10275            // Decode unknown envelopes for gaps in ordinals.
10276            while _next_ordinal_to_read < 3 {
10277                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10278                _next_ordinal_to_read += 1;
10279                next_offset += envelope_size;
10280            }
10281
10282            let next_out_of_line = decoder.next_out_of_line();
10283            let handles_before = decoder.remaining_handles();
10284            if let Some((inlined, num_bytes, num_handles)) =
10285                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10286            {
10287                let member_inline_size =
10288                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10289                if inlined != (member_inline_size <= 4) {
10290                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10291                }
10292                let inner_offset;
10293                let mut inner_depth = depth.clone();
10294                if inlined {
10295                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10296                    inner_offset = next_offset;
10297                } else {
10298                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10299                    inner_depth.increment()?;
10300                }
10301                let val_ref =
10302                    self.ipv6_to_ipv4_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
10303                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10304                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10305                {
10306                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10307                }
10308                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10309                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10310                }
10311            }
10312
10313            next_offset += envelope_size;
10314            _next_ordinal_to_read += 1;
10315            if next_offset >= end_offset {
10316                return Ok(());
10317            }
10318
10319            // Decode unknown envelopes for gaps in ordinals.
10320            while _next_ordinal_to_read < 4 {
10321                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10322                _next_ordinal_to_read += 1;
10323                next_offset += envelope_size;
10324            }
10325
10326            let next_out_of_line = decoder.next_out_of_line();
10327            let handles_before = decoder.remaining_handles();
10328            if let Some((inlined, num_bytes, num_handles)) =
10329                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10330            {
10331                let member_inline_size =
10332                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10333                if inlined != (member_inline_size <= 4) {
10334                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10335                }
10336                let inner_offset;
10337                let mut inner_depth = depth.clone();
10338                if inlined {
10339                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10340                    inner_offset = next_offset;
10341                } else {
10342                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10343                    inner_depth.increment()?;
10344                }
10345                let val_ref =
10346                    self.ipv6_to_ipv4_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
10347                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
10348                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10349                {
10350                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10351                }
10352                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10353                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10354                }
10355            }
10356
10357            next_offset += envelope_size;
10358
10359            // Decode the remaining unknown envelopes.
10360            while next_offset < end_offset {
10361                _next_ordinal_to_read += 1;
10362                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10363                next_offset += envelope_size;
10364            }
10365
10366            Ok(())
10367        }
10368    }
10369
10370    impl NetworkScanParameters {
10371        #[inline(always)]
10372        fn max_ordinal_present(&self) -> u64 {
10373            if let Some(_) = self.tx_power_dbm {
10374                return 2;
10375            }
10376            if let Some(_) = self.channels {
10377                return 1;
10378            }
10379            0
10380        }
10381    }
10382
10383    impl fidl::encoding::ValueTypeMarker for NetworkScanParameters {
10384        type Borrowed<'a> = &'a Self;
10385        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10386            value
10387        }
10388    }
10389
10390    unsafe impl fidl::encoding::TypeMarker for NetworkScanParameters {
10391        type Owned = Self;
10392
10393        #[inline(always)]
10394        fn inline_align(_context: fidl::encoding::Context) -> usize {
10395            8
10396        }
10397
10398        #[inline(always)]
10399        fn inline_size(_context: fidl::encoding::Context) -> usize {
10400            16
10401        }
10402    }
10403
10404    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NetworkScanParameters, D>
10405        for &NetworkScanParameters
10406    {
10407        unsafe fn encode(
10408            self,
10409            encoder: &mut fidl::encoding::Encoder<'_, D>,
10410            offset: usize,
10411            mut depth: fidl::encoding::Depth,
10412        ) -> fidl::Result<()> {
10413            encoder.debug_check_bounds::<NetworkScanParameters>(offset);
10414            // Vector header
10415            let max_ordinal: u64 = self.max_ordinal_present();
10416            encoder.write_num(max_ordinal, offset);
10417            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10418            // Calling encoder.out_of_line_offset(0) is not allowed.
10419            if max_ordinal == 0 {
10420                return Ok(());
10421            }
10422            depth.increment()?;
10423            let envelope_size = 8;
10424            let bytes_len = max_ordinal as usize * envelope_size;
10425            #[allow(unused_variables)]
10426            let offset = encoder.out_of_line_offset(bytes_len);
10427            let mut _prev_end_offset: usize = 0;
10428            if 1 > max_ordinal {
10429                return Ok(());
10430            }
10431
10432            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10433            // are envelope_size bytes.
10434            let cur_offset: usize = (1 - 1) * envelope_size;
10435
10436            // Zero reserved fields.
10437            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10438
10439            // Safety:
10440            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10441            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10442            //   envelope_size bytes, there is always sufficient room.
10443            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u16, 200>, D>(
10444                self.channels.as_ref().map(
10445                    <fidl::encoding::Vector<u16, 200> as fidl::encoding::ValueTypeMarker>::borrow,
10446                ),
10447                encoder,
10448                offset + cur_offset,
10449                depth,
10450            )?;
10451
10452            _prev_end_offset = cur_offset + envelope_size;
10453            if 2 > max_ordinal {
10454                return Ok(());
10455            }
10456
10457            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10458            // are envelope_size bytes.
10459            let cur_offset: usize = (2 - 1) * envelope_size;
10460
10461            // Zero reserved fields.
10462            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10463
10464            // Safety:
10465            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10466            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10467            //   envelope_size bytes, there is always sufficient room.
10468            fidl::encoding::encode_in_envelope_optional::<i8, D>(
10469                self.tx_power_dbm.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
10470                encoder,
10471                offset + cur_offset,
10472                depth,
10473            )?;
10474
10475            _prev_end_offset = cur_offset + envelope_size;
10476
10477            Ok(())
10478        }
10479    }
10480
10481    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NetworkScanParameters {
10482        #[inline(always)]
10483        fn new_empty() -> Self {
10484            Self::default()
10485        }
10486
10487        unsafe fn decode(
10488            &mut self,
10489            decoder: &mut fidl::encoding::Decoder<'_, D>,
10490            offset: usize,
10491            mut depth: fidl::encoding::Depth,
10492        ) -> fidl::Result<()> {
10493            decoder.debug_check_bounds::<Self>(offset);
10494            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10495                None => return Err(fidl::Error::NotNullable),
10496                Some(len) => len,
10497            };
10498            // Calling decoder.out_of_line_offset(0) is not allowed.
10499            if len == 0 {
10500                return Ok(());
10501            };
10502            depth.increment()?;
10503            let envelope_size = 8;
10504            let bytes_len = len * envelope_size;
10505            let offset = decoder.out_of_line_offset(bytes_len)?;
10506            // Decode the envelope for each type.
10507            let mut _next_ordinal_to_read = 0;
10508            let mut next_offset = offset;
10509            let end_offset = offset + bytes_len;
10510            _next_ordinal_to_read += 1;
10511            if next_offset >= end_offset {
10512                return Ok(());
10513            }
10514
10515            // Decode unknown envelopes for gaps in ordinals.
10516            while _next_ordinal_to_read < 1 {
10517                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10518                _next_ordinal_to_read += 1;
10519                next_offset += envelope_size;
10520            }
10521
10522            let next_out_of_line = decoder.next_out_of_line();
10523            let handles_before = decoder.remaining_handles();
10524            if let Some((inlined, num_bytes, num_handles)) =
10525                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10526            {
10527                let member_inline_size =
10528                    <fidl::encoding::Vector<u16, 200> as fidl::encoding::TypeMarker>::inline_size(
10529                        decoder.context,
10530                    );
10531                if inlined != (member_inline_size <= 4) {
10532                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10533                }
10534                let inner_offset;
10535                let mut inner_depth = depth.clone();
10536                if inlined {
10537                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10538                    inner_offset = next_offset;
10539                } else {
10540                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10541                    inner_depth.increment()?;
10542                }
10543                let val_ref = self
10544                    .channels
10545                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u16, 200>, D));
10546                fidl::decode!(fidl::encoding::Vector<u16, 200>, D, val_ref, decoder, inner_offset, inner_depth)?;
10547                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10548                {
10549                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10550                }
10551                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10552                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10553                }
10554            }
10555
10556            next_offset += envelope_size;
10557            _next_ordinal_to_read += 1;
10558            if next_offset >= end_offset {
10559                return Ok(());
10560            }
10561
10562            // Decode unknown envelopes for gaps in ordinals.
10563            while _next_ordinal_to_read < 2 {
10564                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10565                _next_ordinal_to_read += 1;
10566                next_offset += envelope_size;
10567            }
10568
10569            let next_out_of_line = decoder.next_out_of_line();
10570            let handles_before = decoder.remaining_handles();
10571            if let Some((inlined, num_bytes, num_handles)) =
10572                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10573            {
10574                let member_inline_size =
10575                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10576                if inlined != (member_inline_size <= 4) {
10577                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10578                }
10579                let inner_offset;
10580                let mut inner_depth = depth.clone();
10581                if inlined {
10582                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10583                    inner_offset = next_offset;
10584                } else {
10585                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10586                    inner_depth.increment()?;
10587                }
10588                let val_ref = self.tx_power_dbm.get_or_insert_with(|| fidl::new_empty!(i8, D));
10589                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
10590                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10591                {
10592                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10593                }
10594                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10595                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10596                }
10597            }
10598
10599            next_offset += envelope_size;
10600
10601            // Decode the remaining unknown envelopes.
10602            while next_offset < end_offset {
10603                _next_ordinal_to_read += 1;
10604                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10605                next_offset += envelope_size;
10606            }
10607
10608            Ok(())
10609        }
10610    }
10611
10612    impl OnMeshPrefix {
10613        #[inline(always)]
10614        fn max_ordinal_present(&self) -> u64 {
10615            if let Some(_) = self.slaac_valid {
10616                return 5;
10617            }
10618            if let Some(_) = self.slaac_preferred {
10619                return 4;
10620            }
10621            if let Some(_) = self.stable {
10622                return 3;
10623            }
10624            if let Some(_) = self.default_route_preference {
10625                return 2;
10626            }
10627            if let Some(_) = self.subnet {
10628                return 1;
10629            }
10630            0
10631        }
10632    }
10633
10634    impl fidl::encoding::ValueTypeMarker for OnMeshPrefix {
10635        type Borrowed<'a> = &'a Self;
10636        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
10637            value
10638        }
10639    }
10640
10641    unsafe impl fidl::encoding::TypeMarker for OnMeshPrefix {
10642        type Owned = Self;
10643
10644        #[inline(always)]
10645        fn inline_align(_context: fidl::encoding::Context) -> usize {
10646            8
10647        }
10648
10649        #[inline(always)]
10650        fn inline_size(_context: fidl::encoding::Context) -> usize {
10651            16
10652        }
10653    }
10654
10655    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<OnMeshPrefix, D>
10656        for &OnMeshPrefix
10657    {
10658        unsafe fn encode(
10659            self,
10660            encoder: &mut fidl::encoding::Encoder<'_, D>,
10661            offset: usize,
10662            mut depth: fidl::encoding::Depth,
10663        ) -> fidl::Result<()> {
10664            encoder.debug_check_bounds::<OnMeshPrefix>(offset);
10665            // Vector header
10666            let max_ordinal: u64 = self.max_ordinal_present();
10667            encoder.write_num(max_ordinal, offset);
10668            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
10669            // Calling encoder.out_of_line_offset(0) is not allowed.
10670            if max_ordinal == 0 {
10671                return Ok(());
10672            }
10673            depth.increment()?;
10674            let envelope_size = 8;
10675            let bytes_len = max_ordinal as usize * envelope_size;
10676            #[allow(unused_variables)]
10677            let offset = encoder.out_of_line_offset(bytes_len);
10678            let mut _prev_end_offset: usize = 0;
10679            if 1 > max_ordinal {
10680                return Ok(());
10681            }
10682
10683            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10684            // are envelope_size bytes.
10685            let cur_offset: usize = (1 - 1) * envelope_size;
10686
10687            // Zero reserved fields.
10688            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10689
10690            // Safety:
10691            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10692            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10693            //   envelope_size bytes, there is always sufficient room.
10694            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D>(
10695            self.subnet.as_ref().map(<fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::ValueTypeMarker>::borrow),
10696            encoder, offset + cur_offset, depth
10697        )?;
10698
10699            _prev_end_offset = cur_offset + envelope_size;
10700            if 2 > max_ordinal {
10701                return Ok(());
10702            }
10703
10704            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10705            // are envelope_size bytes.
10706            let cur_offset: usize = (2 - 1) * envelope_size;
10707
10708            // Zero reserved fields.
10709            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10710
10711            // Safety:
10712            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10713            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10714            //   envelope_size bytes, there is always sufficient room.
10715            fidl::encoding::encode_in_envelope_optional::<RoutePreference, D>(
10716                self.default_route_preference
10717                    .as_ref()
10718                    .map(<RoutePreference as fidl::encoding::ValueTypeMarker>::borrow),
10719                encoder,
10720                offset + cur_offset,
10721                depth,
10722            )?;
10723
10724            _prev_end_offset = cur_offset + envelope_size;
10725            if 3 > max_ordinal {
10726                return Ok(());
10727            }
10728
10729            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10730            // are envelope_size bytes.
10731            let cur_offset: usize = (3 - 1) * envelope_size;
10732
10733            // Zero reserved fields.
10734            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10735
10736            // Safety:
10737            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10738            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10739            //   envelope_size bytes, there is always sufficient room.
10740            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10741                self.stable.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10742                encoder,
10743                offset + cur_offset,
10744                depth,
10745            )?;
10746
10747            _prev_end_offset = cur_offset + envelope_size;
10748            if 4 > max_ordinal {
10749                return Ok(());
10750            }
10751
10752            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10753            // are envelope_size bytes.
10754            let cur_offset: usize = (4 - 1) * envelope_size;
10755
10756            // Zero reserved fields.
10757            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10758
10759            // Safety:
10760            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10761            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10762            //   envelope_size bytes, there is always sufficient room.
10763            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10764                self.slaac_preferred
10765                    .as_ref()
10766                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10767                encoder,
10768                offset + cur_offset,
10769                depth,
10770            )?;
10771
10772            _prev_end_offset = cur_offset + envelope_size;
10773            if 5 > max_ordinal {
10774                return Ok(());
10775            }
10776
10777            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
10778            // are envelope_size bytes.
10779            let cur_offset: usize = (5 - 1) * envelope_size;
10780
10781            // Zero reserved fields.
10782            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
10783
10784            // Safety:
10785            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
10786            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
10787            //   envelope_size bytes, there is always sufficient room.
10788            fidl::encoding::encode_in_envelope_optional::<bool, D>(
10789                self.slaac_valid.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
10790                encoder,
10791                offset + cur_offset,
10792                depth,
10793            )?;
10794
10795            _prev_end_offset = cur_offset + envelope_size;
10796
10797            Ok(())
10798        }
10799    }
10800
10801    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OnMeshPrefix {
10802        #[inline(always)]
10803        fn new_empty() -> Self {
10804            Self::default()
10805        }
10806
10807        unsafe fn decode(
10808            &mut self,
10809            decoder: &mut fidl::encoding::Decoder<'_, D>,
10810            offset: usize,
10811            mut depth: fidl::encoding::Depth,
10812        ) -> fidl::Result<()> {
10813            decoder.debug_check_bounds::<Self>(offset);
10814            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
10815                None => return Err(fidl::Error::NotNullable),
10816                Some(len) => len,
10817            };
10818            // Calling decoder.out_of_line_offset(0) is not allowed.
10819            if len == 0 {
10820                return Ok(());
10821            };
10822            depth.increment()?;
10823            let envelope_size = 8;
10824            let bytes_len = len * envelope_size;
10825            let offset = decoder.out_of_line_offset(bytes_len)?;
10826            // Decode the envelope for each type.
10827            let mut _next_ordinal_to_read = 0;
10828            let mut next_offset = offset;
10829            let end_offset = offset + bytes_len;
10830            _next_ordinal_to_read += 1;
10831            if next_offset >= end_offset {
10832                return Ok(());
10833            }
10834
10835            // Decode unknown envelopes for gaps in ordinals.
10836            while _next_ordinal_to_read < 1 {
10837                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10838                _next_ordinal_to_read += 1;
10839                next_offset += envelope_size;
10840            }
10841
10842            let next_out_of_line = decoder.next_out_of_line();
10843            let handles_before = decoder.remaining_handles();
10844            if let Some((inlined, num_bytes, num_handles)) =
10845                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10846            {
10847                let member_inline_size = <fidl_fuchsia_net__common::Ipv6AddressWithPrefix as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10848                if inlined != (member_inline_size <= 4) {
10849                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10850                }
10851                let inner_offset;
10852                let mut inner_depth = depth.clone();
10853                if inlined {
10854                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10855                    inner_offset = next_offset;
10856                } else {
10857                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10858                    inner_depth.increment()?;
10859                }
10860                let val_ref = self.subnet.get_or_insert_with(|| {
10861                    fidl::new_empty!(fidl_fuchsia_net__common::Ipv6AddressWithPrefix, D)
10862                });
10863                fidl::decode!(
10864                    fidl_fuchsia_net__common::Ipv6AddressWithPrefix,
10865                    D,
10866                    val_ref,
10867                    decoder,
10868                    inner_offset,
10869                    inner_depth
10870                )?;
10871                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10872                {
10873                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10874                }
10875                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10876                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10877                }
10878            }
10879
10880            next_offset += envelope_size;
10881            _next_ordinal_to_read += 1;
10882            if next_offset >= end_offset {
10883                return Ok(());
10884            }
10885
10886            // Decode unknown envelopes for gaps in ordinals.
10887            while _next_ordinal_to_read < 2 {
10888                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10889                _next_ordinal_to_read += 1;
10890                next_offset += envelope_size;
10891            }
10892
10893            let next_out_of_line = decoder.next_out_of_line();
10894            let handles_before = decoder.remaining_handles();
10895            if let Some((inlined, num_bytes, num_handles)) =
10896                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10897            {
10898                let member_inline_size =
10899                    <RoutePreference as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10900                if inlined != (member_inline_size <= 4) {
10901                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10902                }
10903                let inner_offset;
10904                let mut inner_depth = depth.clone();
10905                if inlined {
10906                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10907                    inner_offset = next_offset;
10908                } else {
10909                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10910                    inner_depth.increment()?;
10911                }
10912                let val_ref = self
10913                    .default_route_preference
10914                    .get_or_insert_with(|| fidl::new_empty!(RoutePreference, D));
10915                fidl::decode!(RoutePreference, D, val_ref, decoder, inner_offset, inner_depth)?;
10916                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10917                {
10918                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10919                }
10920                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10921                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10922                }
10923            }
10924
10925            next_offset += envelope_size;
10926            _next_ordinal_to_read += 1;
10927            if next_offset >= end_offset {
10928                return Ok(());
10929            }
10930
10931            // Decode unknown envelopes for gaps in ordinals.
10932            while _next_ordinal_to_read < 3 {
10933                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10934                _next_ordinal_to_read += 1;
10935                next_offset += envelope_size;
10936            }
10937
10938            let next_out_of_line = decoder.next_out_of_line();
10939            let handles_before = decoder.remaining_handles();
10940            if let Some((inlined, num_bytes, num_handles)) =
10941                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10942            {
10943                let member_inline_size =
10944                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10945                if inlined != (member_inline_size <= 4) {
10946                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10947                }
10948                let inner_offset;
10949                let mut inner_depth = depth.clone();
10950                if inlined {
10951                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10952                    inner_offset = next_offset;
10953                } else {
10954                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10955                    inner_depth.increment()?;
10956                }
10957                let val_ref = self.stable.get_or_insert_with(|| fidl::new_empty!(bool, D));
10958                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
10959                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
10960                {
10961                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
10962                }
10963                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
10964                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
10965                }
10966            }
10967
10968            next_offset += envelope_size;
10969            _next_ordinal_to_read += 1;
10970            if next_offset >= end_offset {
10971                return Ok(());
10972            }
10973
10974            // Decode unknown envelopes for gaps in ordinals.
10975            while _next_ordinal_to_read < 4 {
10976                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
10977                _next_ordinal_to_read += 1;
10978                next_offset += envelope_size;
10979            }
10980
10981            let next_out_of_line = decoder.next_out_of_line();
10982            let handles_before = decoder.remaining_handles();
10983            if let Some((inlined, num_bytes, num_handles)) =
10984                fidl::encoding::decode_envelope_header(decoder, next_offset)?
10985            {
10986                let member_inline_size =
10987                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
10988                if inlined != (member_inline_size <= 4) {
10989                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
10990                }
10991                let inner_offset;
10992                let mut inner_depth = depth.clone();
10993                if inlined {
10994                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
10995                    inner_offset = next_offset;
10996                } else {
10997                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
10998                    inner_depth.increment()?;
10999                }
11000                let val_ref = self.slaac_preferred.get_or_insert_with(|| fidl::new_empty!(bool, D));
11001                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
11002                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11003                {
11004                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11005                }
11006                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11007                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11008                }
11009            }
11010
11011            next_offset += envelope_size;
11012            _next_ordinal_to_read += 1;
11013            if next_offset >= end_offset {
11014                return Ok(());
11015            }
11016
11017            // Decode unknown envelopes for gaps in ordinals.
11018            while _next_ordinal_to_read < 5 {
11019                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11020                _next_ordinal_to_read += 1;
11021                next_offset += envelope_size;
11022            }
11023
11024            let next_out_of_line = decoder.next_out_of_line();
11025            let handles_before = decoder.remaining_handles();
11026            if let Some((inlined, num_bytes, num_handles)) =
11027                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11028            {
11029                let member_inline_size =
11030                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11031                if inlined != (member_inline_size <= 4) {
11032                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11033                }
11034                let inner_offset;
11035                let mut inner_depth = depth.clone();
11036                if inlined {
11037                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11038                    inner_offset = next_offset;
11039                } else {
11040                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11041                    inner_depth.increment()?;
11042                }
11043                let val_ref = self.slaac_valid.get_or_insert_with(|| fidl::new_empty!(bool, D));
11044                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
11045                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11046                {
11047                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11048                }
11049                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11050                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11051                }
11052            }
11053
11054            next_offset += envelope_size;
11055
11056            // Decode the remaining unknown envelopes.
11057            while next_offset < end_offset {
11058                _next_ordinal_to_read += 1;
11059                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11060                next_offset += envelope_size;
11061            }
11062
11063            Ok(())
11064        }
11065    }
11066
11067    impl PdProcessedRaInfo {
11068        #[inline(always)]
11069        fn max_ordinal_present(&self) -> u64 {
11070            if let Some(_) = self.last_platform_ra_msec {
11071                return 3;
11072            }
11073            if let Some(_) = self.num_platform_pio_processed {
11074                return 2;
11075            }
11076            if let Some(_) = self.num_platform_ra_received {
11077                return 1;
11078            }
11079            0
11080        }
11081    }
11082
11083    impl fidl::encoding::ValueTypeMarker for PdProcessedRaInfo {
11084        type Borrowed<'a> = &'a Self;
11085        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11086            value
11087        }
11088    }
11089
11090    unsafe impl fidl::encoding::TypeMarker for PdProcessedRaInfo {
11091        type Owned = Self;
11092
11093        #[inline(always)]
11094        fn inline_align(_context: fidl::encoding::Context) -> usize {
11095            8
11096        }
11097
11098        #[inline(always)]
11099        fn inline_size(_context: fidl::encoding::Context) -> usize {
11100            16
11101        }
11102    }
11103
11104    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PdProcessedRaInfo, D>
11105        for &PdProcessedRaInfo
11106    {
11107        unsafe fn encode(
11108            self,
11109            encoder: &mut fidl::encoding::Encoder<'_, D>,
11110            offset: usize,
11111            mut depth: fidl::encoding::Depth,
11112        ) -> fidl::Result<()> {
11113            encoder.debug_check_bounds::<PdProcessedRaInfo>(offset);
11114            // Vector header
11115            let max_ordinal: u64 = self.max_ordinal_present();
11116            encoder.write_num(max_ordinal, offset);
11117            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11118            // Calling encoder.out_of_line_offset(0) is not allowed.
11119            if max_ordinal == 0 {
11120                return Ok(());
11121            }
11122            depth.increment()?;
11123            let envelope_size = 8;
11124            let bytes_len = max_ordinal as usize * envelope_size;
11125            #[allow(unused_variables)]
11126            let offset = encoder.out_of_line_offset(bytes_len);
11127            let mut _prev_end_offset: usize = 0;
11128            if 1 > max_ordinal {
11129                return Ok(());
11130            }
11131
11132            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11133            // are envelope_size bytes.
11134            let cur_offset: usize = (1 - 1) * envelope_size;
11135
11136            // Zero reserved fields.
11137            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11138
11139            // Safety:
11140            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11141            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11142            //   envelope_size bytes, there is always sufficient room.
11143            fidl::encoding::encode_in_envelope_optional::<u32, D>(
11144                self.num_platform_ra_received
11145                    .as_ref()
11146                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
11147                encoder,
11148                offset + cur_offset,
11149                depth,
11150            )?;
11151
11152            _prev_end_offset = cur_offset + envelope_size;
11153            if 2 > max_ordinal {
11154                return Ok(());
11155            }
11156
11157            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11158            // are envelope_size bytes.
11159            let cur_offset: usize = (2 - 1) * envelope_size;
11160
11161            // Zero reserved fields.
11162            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11163
11164            // Safety:
11165            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11166            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11167            //   envelope_size bytes, there is always sufficient room.
11168            fidl::encoding::encode_in_envelope_optional::<u32, D>(
11169                self.num_platform_pio_processed
11170                    .as_ref()
11171                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
11172                encoder,
11173                offset + cur_offset,
11174                depth,
11175            )?;
11176
11177            _prev_end_offset = cur_offset + envelope_size;
11178            if 3 > max_ordinal {
11179                return Ok(());
11180            }
11181
11182            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11183            // are envelope_size bytes.
11184            let cur_offset: usize = (3 - 1) * envelope_size;
11185
11186            // Zero reserved fields.
11187            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11188
11189            // Safety:
11190            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11191            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11192            //   envelope_size bytes, there is always sufficient room.
11193            fidl::encoding::encode_in_envelope_optional::<u32, D>(
11194                self.last_platform_ra_msec
11195                    .as_ref()
11196                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
11197                encoder,
11198                offset + cur_offset,
11199                depth,
11200            )?;
11201
11202            _prev_end_offset = cur_offset + envelope_size;
11203
11204            Ok(())
11205        }
11206    }
11207
11208    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PdProcessedRaInfo {
11209        #[inline(always)]
11210        fn new_empty() -> Self {
11211            Self::default()
11212        }
11213
11214        unsafe fn decode(
11215            &mut self,
11216            decoder: &mut fidl::encoding::Decoder<'_, D>,
11217            offset: usize,
11218            mut depth: fidl::encoding::Depth,
11219        ) -> fidl::Result<()> {
11220            decoder.debug_check_bounds::<Self>(offset);
11221            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11222                None => return Err(fidl::Error::NotNullable),
11223                Some(len) => len,
11224            };
11225            // Calling decoder.out_of_line_offset(0) is not allowed.
11226            if len == 0 {
11227                return Ok(());
11228            };
11229            depth.increment()?;
11230            let envelope_size = 8;
11231            let bytes_len = len * envelope_size;
11232            let offset = decoder.out_of_line_offset(bytes_len)?;
11233            // Decode the envelope for each type.
11234            let mut _next_ordinal_to_read = 0;
11235            let mut next_offset = offset;
11236            let end_offset = offset + bytes_len;
11237            _next_ordinal_to_read += 1;
11238            if next_offset >= end_offset {
11239                return Ok(());
11240            }
11241
11242            // Decode unknown envelopes for gaps in ordinals.
11243            while _next_ordinal_to_read < 1 {
11244                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11245                _next_ordinal_to_read += 1;
11246                next_offset += envelope_size;
11247            }
11248
11249            let next_out_of_line = decoder.next_out_of_line();
11250            let handles_before = decoder.remaining_handles();
11251            if let Some((inlined, num_bytes, num_handles)) =
11252                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11253            {
11254                let member_inline_size =
11255                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11256                if inlined != (member_inline_size <= 4) {
11257                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11258                }
11259                let inner_offset;
11260                let mut inner_depth = depth.clone();
11261                if inlined {
11262                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11263                    inner_offset = next_offset;
11264                } else {
11265                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11266                    inner_depth.increment()?;
11267                }
11268                let val_ref =
11269                    self.num_platform_ra_received.get_or_insert_with(|| fidl::new_empty!(u32, D));
11270                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
11271                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11272                {
11273                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11274                }
11275                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11276                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11277                }
11278            }
11279
11280            next_offset += envelope_size;
11281            _next_ordinal_to_read += 1;
11282            if next_offset >= end_offset {
11283                return Ok(());
11284            }
11285
11286            // Decode unknown envelopes for gaps in ordinals.
11287            while _next_ordinal_to_read < 2 {
11288                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11289                _next_ordinal_to_read += 1;
11290                next_offset += envelope_size;
11291            }
11292
11293            let next_out_of_line = decoder.next_out_of_line();
11294            let handles_before = decoder.remaining_handles();
11295            if let Some((inlined, num_bytes, num_handles)) =
11296                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11297            {
11298                let member_inline_size =
11299                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11300                if inlined != (member_inline_size <= 4) {
11301                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11302                }
11303                let inner_offset;
11304                let mut inner_depth = depth.clone();
11305                if inlined {
11306                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11307                    inner_offset = next_offset;
11308                } else {
11309                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11310                    inner_depth.increment()?;
11311                }
11312                let val_ref =
11313                    self.num_platform_pio_processed.get_or_insert_with(|| fidl::new_empty!(u32, D));
11314                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
11315                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11316                {
11317                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11318                }
11319                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11320                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11321                }
11322            }
11323
11324            next_offset += envelope_size;
11325            _next_ordinal_to_read += 1;
11326            if next_offset >= end_offset {
11327                return Ok(());
11328            }
11329
11330            // Decode unknown envelopes for gaps in ordinals.
11331            while _next_ordinal_to_read < 3 {
11332                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11333                _next_ordinal_to_read += 1;
11334                next_offset += envelope_size;
11335            }
11336
11337            let next_out_of_line = decoder.next_out_of_line();
11338            let handles_before = decoder.remaining_handles();
11339            if let Some((inlined, num_bytes, num_handles)) =
11340                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11341            {
11342                let member_inline_size =
11343                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11344                if inlined != (member_inline_size <= 4) {
11345                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11346                }
11347                let inner_offset;
11348                let mut inner_depth = depth.clone();
11349                if inlined {
11350                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11351                    inner_offset = next_offset;
11352                } else {
11353                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11354                    inner_depth.increment()?;
11355                }
11356                let val_ref =
11357                    self.last_platform_ra_msec.get_or_insert_with(|| fidl::new_empty!(u32, D));
11358                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
11359                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11360                {
11361                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11362                }
11363                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11364                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11365                }
11366            }
11367
11368            next_offset += envelope_size;
11369
11370            // Decode the remaining unknown envelopes.
11371            while next_offset < end_offset {
11372                _next_ordinal_to_read += 1;
11373                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11374                next_offset += envelope_size;
11375            }
11376
11377            Ok(())
11378        }
11379    }
11380
11381    impl SrpServerInfo {
11382        #[inline(always)]
11383        fn max_ordinal_present(&self) -> u64 {
11384            if let Some(_) = self.services_registration {
11385                return 6;
11386            }
11387            if let Some(_) = self.hosts_registration {
11388                return 5;
11389            }
11390            if let Some(_) = self.response_counters {
11391                return 4;
11392            }
11393            if let Some(_) = self.address_mode {
11394                return 3;
11395            }
11396            if let Some(_) = self.port {
11397                return 2;
11398            }
11399            if let Some(_) = self.state {
11400                return 1;
11401            }
11402            0
11403        }
11404    }
11405
11406    impl fidl::encoding::ValueTypeMarker for SrpServerInfo {
11407        type Borrowed<'a> = &'a Self;
11408        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11409            value
11410        }
11411    }
11412
11413    unsafe impl fidl::encoding::TypeMarker for SrpServerInfo {
11414        type Owned = Self;
11415
11416        #[inline(always)]
11417        fn inline_align(_context: fidl::encoding::Context) -> usize {
11418            8
11419        }
11420
11421        #[inline(always)]
11422        fn inline_size(_context: fidl::encoding::Context) -> usize {
11423            16
11424        }
11425    }
11426
11427    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SrpServerInfo, D>
11428        for &SrpServerInfo
11429    {
11430        unsafe fn encode(
11431            self,
11432            encoder: &mut fidl::encoding::Encoder<'_, D>,
11433            offset: usize,
11434            mut depth: fidl::encoding::Depth,
11435        ) -> fidl::Result<()> {
11436            encoder.debug_check_bounds::<SrpServerInfo>(offset);
11437            // Vector header
11438            let max_ordinal: u64 = self.max_ordinal_present();
11439            encoder.write_num(max_ordinal, offset);
11440            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
11441            // Calling encoder.out_of_line_offset(0) is not allowed.
11442            if max_ordinal == 0 {
11443                return Ok(());
11444            }
11445            depth.increment()?;
11446            let envelope_size = 8;
11447            let bytes_len = max_ordinal as usize * envelope_size;
11448            #[allow(unused_variables)]
11449            let offset = encoder.out_of_line_offset(bytes_len);
11450            let mut _prev_end_offset: usize = 0;
11451            if 1 > max_ordinal {
11452                return Ok(());
11453            }
11454
11455            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11456            // are envelope_size bytes.
11457            let cur_offset: usize = (1 - 1) * envelope_size;
11458
11459            // Zero reserved fields.
11460            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11461
11462            // Safety:
11463            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11464            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11465            //   envelope_size bytes, there is always sufficient room.
11466            fidl::encoding::encode_in_envelope_optional::<SrpServerState, D>(
11467                self.state
11468                    .as_ref()
11469                    .map(<SrpServerState as fidl::encoding::ValueTypeMarker>::borrow),
11470                encoder,
11471                offset + cur_offset,
11472                depth,
11473            )?;
11474
11475            _prev_end_offset = cur_offset + envelope_size;
11476            if 2 > max_ordinal {
11477                return Ok(());
11478            }
11479
11480            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11481            // are envelope_size bytes.
11482            let cur_offset: usize = (2 - 1) * envelope_size;
11483
11484            // Zero reserved fields.
11485            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11486
11487            // Safety:
11488            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11489            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11490            //   envelope_size bytes, there is always sufficient room.
11491            fidl::encoding::encode_in_envelope_optional::<u16, D>(
11492                self.port.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
11493                encoder,
11494                offset + cur_offset,
11495                depth,
11496            )?;
11497
11498            _prev_end_offset = cur_offset + envelope_size;
11499            if 3 > max_ordinal {
11500                return Ok(());
11501            }
11502
11503            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11504            // are envelope_size bytes.
11505            let cur_offset: usize = (3 - 1) * envelope_size;
11506
11507            // Zero reserved fields.
11508            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11509
11510            // Safety:
11511            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11512            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11513            //   envelope_size bytes, there is always sufficient room.
11514            fidl::encoding::encode_in_envelope_optional::<SrpServerAddressMode, D>(
11515                self.address_mode
11516                    .as_ref()
11517                    .map(<SrpServerAddressMode as fidl::encoding::ValueTypeMarker>::borrow),
11518                encoder,
11519                offset + cur_offset,
11520                depth,
11521            )?;
11522
11523            _prev_end_offset = cur_offset + envelope_size;
11524            if 4 > max_ordinal {
11525                return Ok(());
11526            }
11527
11528            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11529            // are envelope_size bytes.
11530            let cur_offset: usize = (4 - 1) * envelope_size;
11531
11532            // Zero reserved fields.
11533            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11534
11535            // Safety:
11536            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11537            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11538            //   envelope_size bytes, there is always sufficient room.
11539            fidl::encoding::encode_in_envelope_optional::<SrpServerResponseCounters, D>(
11540                self.response_counters
11541                    .as_ref()
11542                    .map(<SrpServerResponseCounters as fidl::encoding::ValueTypeMarker>::borrow),
11543                encoder,
11544                offset + cur_offset,
11545                depth,
11546            )?;
11547
11548            _prev_end_offset = cur_offset + envelope_size;
11549            if 5 > max_ordinal {
11550                return Ok(());
11551            }
11552
11553            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11554            // are envelope_size bytes.
11555            let cur_offset: usize = (5 - 1) * envelope_size;
11556
11557            // Zero reserved fields.
11558            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11559
11560            // Safety:
11561            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11562            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11563            //   envelope_size bytes, there is always sufficient room.
11564            fidl::encoding::encode_in_envelope_optional::<SrpServerRegistration, D>(
11565                self.hosts_registration
11566                    .as_ref()
11567                    .map(<SrpServerRegistration as fidl::encoding::ValueTypeMarker>::borrow),
11568                encoder,
11569                offset + cur_offset,
11570                depth,
11571            )?;
11572
11573            _prev_end_offset = cur_offset + envelope_size;
11574            if 6 > max_ordinal {
11575                return Ok(());
11576            }
11577
11578            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
11579            // are envelope_size bytes.
11580            let cur_offset: usize = (6 - 1) * envelope_size;
11581
11582            // Zero reserved fields.
11583            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
11584
11585            // Safety:
11586            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
11587            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
11588            //   envelope_size bytes, there is always sufficient room.
11589            fidl::encoding::encode_in_envelope_optional::<SrpServerRegistration, D>(
11590                self.services_registration
11591                    .as_ref()
11592                    .map(<SrpServerRegistration as fidl::encoding::ValueTypeMarker>::borrow),
11593                encoder,
11594                offset + cur_offset,
11595                depth,
11596            )?;
11597
11598            _prev_end_offset = cur_offset + envelope_size;
11599
11600            Ok(())
11601        }
11602    }
11603
11604    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SrpServerInfo {
11605        #[inline(always)]
11606        fn new_empty() -> Self {
11607            Self::default()
11608        }
11609
11610        unsafe fn decode(
11611            &mut self,
11612            decoder: &mut fidl::encoding::Decoder<'_, D>,
11613            offset: usize,
11614            mut depth: fidl::encoding::Depth,
11615        ) -> fidl::Result<()> {
11616            decoder.debug_check_bounds::<Self>(offset);
11617            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
11618                None => return Err(fidl::Error::NotNullable),
11619                Some(len) => len,
11620            };
11621            // Calling decoder.out_of_line_offset(0) is not allowed.
11622            if len == 0 {
11623                return Ok(());
11624            };
11625            depth.increment()?;
11626            let envelope_size = 8;
11627            let bytes_len = len * envelope_size;
11628            let offset = decoder.out_of_line_offset(bytes_len)?;
11629            // Decode the envelope for each type.
11630            let mut _next_ordinal_to_read = 0;
11631            let mut next_offset = offset;
11632            let end_offset = offset + bytes_len;
11633            _next_ordinal_to_read += 1;
11634            if next_offset >= end_offset {
11635                return Ok(());
11636            }
11637
11638            // Decode unknown envelopes for gaps in ordinals.
11639            while _next_ordinal_to_read < 1 {
11640                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11641                _next_ordinal_to_read += 1;
11642                next_offset += envelope_size;
11643            }
11644
11645            let next_out_of_line = decoder.next_out_of_line();
11646            let handles_before = decoder.remaining_handles();
11647            if let Some((inlined, num_bytes, num_handles)) =
11648                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11649            {
11650                let member_inline_size =
11651                    <SrpServerState as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11652                if inlined != (member_inline_size <= 4) {
11653                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11654                }
11655                let inner_offset;
11656                let mut inner_depth = depth.clone();
11657                if inlined {
11658                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11659                    inner_offset = next_offset;
11660                } else {
11661                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11662                    inner_depth.increment()?;
11663                }
11664                let val_ref = self.state.get_or_insert_with(|| fidl::new_empty!(SrpServerState, D));
11665                fidl::decode!(SrpServerState, D, val_ref, decoder, inner_offset, inner_depth)?;
11666                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11667                {
11668                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11669                }
11670                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11671                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11672                }
11673            }
11674
11675            next_offset += envelope_size;
11676            _next_ordinal_to_read += 1;
11677            if next_offset >= end_offset {
11678                return Ok(());
11679            }
11680
11681            // Decode unknown envelopes for gaps in ordinals.
11682            while _next_ordinal_to_read < 2 {
11683                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11684                _next_ordinal_to_read += 1;
11685                next_offset += envelope_size;
11686            }
11687
11688            let next_out_of_line = decoder.next_out_of_line();
11689            let handles_before = decoder.remaining_handles();
11690            if let Some((inlined, num_bytes, num_handles)) =
11691                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11692            {
11693                let member_inline_size =
11694                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
11695                if inlined != (member_inline_size <= 4) {
11696                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11697                }
11698                let inner_offset;
11699                let mut inner_depth = depth.clone();
11700                if inlined {
11701                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11702                    inner_offset = next_offset;
11703                } else {
11704                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11705                    inner_depth.increment()?;
11706                }
11707                let val_ref = self.port.get_or_insert_with(|| fidl::new_empty!(u16, D));
11708                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
11709                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11710                {
11711                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11712                }
11713                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11714                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11715                }
11716            }
11717
11718            next_offset += envelope_size;
11719            _next_ordinal_to_read += 1;
11720            if next_offset >= end_offset {
11721                return Ok(());
11722            }
11723
11724            // Decode unknown envelopes for gaps in ordinals.
11725            while _next_ordinal_to_read < 3 {
11726                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11727                _next_ordinal_to_read += 1;
11728                next_offset += envelope_size;
11729            }
11730
11731            let next_out_of_line = decoder.next_out_of_line();
11732            let handles_before = decoder.remaining_handles();
11733            if let Some((inlined, num_bytes, num_handles)) =
11734                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11735            {
11736                let member_inline_size =
11737                    <SrpServerAddressMode as fidl::encoding::TypeMarker>::inline_size(
11738                        decoder.context,
11739                    );
11740                if inlined != (member_inline_size <= 4) {
11741                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11742                }
11743                let inner_offset;
11744                let mut inner_depth = depth.clone();
11745                if inlined {
11746                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11747                    inner_offset = next_offset;
11748                } else {
11749                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11750                    inner_depth.increment()?;
11751                }
11752                let val_ref = self
11753                    .address_mode
11754                    .get_or_insert_with(|| fidl::new_empty!(SrpServerAddressMode, D));
11755                fidl::decode!(
11756                    SrpServerAddressMode,
11757                    D,
11758                    val_ref,
11759                    decoder,
11760                    inner_offset,
11761                    inner_depth
11762                )?;
11763                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11764                {
11765                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11766                }
11767                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11768                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11769                }
11770            }
11771
11772            next_offset += envelope_size;
11773            _next_ordinal_to_read += 1;
11774            if next_offset >= end_offset {
11775                return Ok(());
11776            }
11777
11778            // Decode unknown envelopes for gaps in ordinals.
11779            while _next_ordinal_to_read < 4 {
11780                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11781                _next_ordinal_to_read += 1;
11782                next_offset += envelope_size;
11783            }
11784
11785            let next_out_of_line = decoder.next_out_of_line();
11786            let handles_before = decoder.remaining_handles();
11787            if let Some((inlined, num_bytes, num_handles)) =
11788                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11789            {
11790                let member_inline_size =
11791                    <SrpServerResponseCounters as fidl::encoding::TypeMarker>::inline_size(
11792                        decoder.context,
11793                    );
11794                if inlined != (member_inline_size <= 4) {
11795                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11796                }
11797                let inner_offset;
11798                let mut inner_depth = depth.clone();
11799                if inlined {
11800                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11801                    inner_offset = next_offset;
11802                } else {
11803                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11804                    inner_depth.increment()?;
11805                }
11806                let val_ref = self
11807                    .response_counters
11808                    .get_or_insert_with(|| fidl::new_empty!(SrpServerResponseCounters, D));
11809                fidl::decode!(
11810                    SrpServerResponseCounters,
11811                    D,
11812                    val_ref,
11813                    decoder,
11814                    inner_offset,
11815                    inner_depth
11816                )?;
11817                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11818                {
11819                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11820                }
11821                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11822                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11823                }
11824            }
11825
11826            next_offset += envelope_size;
11827            _next_ordinal_to_read += 1;
11828            if next_offset >= end_offset {
11829                return Ok(());
11830            }
11831
11832            // Decode unknown envelopes for gaps in ordinals.
11833            while _next_ordinal_to_read < 5 {
11834                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11835                _next_ordinal_to_read += 1;
11836                next_offset += envelope_size;
11837            }
11838
11839            let next_out_of_line = decoder.next_out_of_line();
11840            let handles_before = decoder.remaining_handles();
11841            if let Some((inlined, num_bytes, num_handles)) =
11842                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11843            {
11844                let member_inline_size =
11845                    <SrpServerRegistration as fidl::encoding::TypeMarker>::inline_size(
11846                        decoder.context,
11847                    );
11848                if inlined != (member_inline_size <= 4) {
11849                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11850                }
11851                let inner_offset;
11852                let mut inner_depth = depth.clone();
11853                if inlined {
11854                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11855                    inner_offset = next_offset;
11856                } else {
11857                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11858                    inner_depth.increment()?;
11859                }
11860                let val_ref = self
11861                    .hosts_registration
11862                    .get_or_insert_with(|| fidl::new_empty!(SrpServerRegistration, D));
11863                fidl::decode!(
11864                    SrpServerRegistration,
11865                    D,
11866                    val_ref,
11867                    decoder,
11868                    inner_offset,
11869                    inner_depth
11870                )?;
11871                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11872                {
11873                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11874                }
11875                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11876                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11877                }
11878            }
11879
11880            next_offset += envelope_size;
11881            _next_ordinal_to_read += 1;
11882            if next_offset >= end_offset {
11883                return Ok(());
11884            }
11885
11886            // Decode unknown envelopes for gaps in ordinals.
11887            while _next_ordinal_to_read < 6 {
11888                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11889                _next_ordinal_to_read += 1;
11890                next_offset += envelope_size;
11891            }
11892
11893            let next_out_of_line = decoder.next_out_of_line();
11894            let handles_before = decoder.remaining_handles();
11895            if let Some((inlined, num_bytes, num_handles)) =
11896                fidl::encoding::decode_envelope_header(decoder, next_offset)?
11897            {
11898                let member_inline_size =
11899                    <SrpServerRegistration as fidl::encoding::TypeMarker>::inline_size(
11900                        decoder.context,
11901                    );
11902                if inlined != (member_inline_size <= 4) {
11903                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
11904                }
11905                let inner_offset;
11906                let mut inner_depth = depth.clone();
11907                if inlined {
11908                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
11909                    inner_offset = next_offset;
11910                } else {
11911                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
11912                    inner_depth.increment()?;
11913                }
11914                let val_ref = self
11915                    .services_registration
11916                    .get_or_insert_with(|| fidl::new_empty!(SrpServerRegistration, D));
11917                fidl::decode!(
11918                    SrpServerRegistration,
11919                    D,
11920                    val_ref,
11921                    decoder,
11922                    inner_offset,
11923                    inner_depth
11924                )?;
11925                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
11926                {
11927                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
11928                }
11929                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
11930                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
11931                }
11932            }
11933
11934            next_offset += envelope_size;
11935
11936            // Decode the remaining unknown envelopes.
11937            while next_offset < end_offset {
11938                _next_ordinal_to_read += 1;
11939                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
11940                next_offset += envelope_size;
11941            }
11942
11943            Ok(())
11944        }
11945    }
11946
11947    impl SrpServerRegistration {
11948        #[inline(always)]
11949        fn max_ordinal_present(&self) -> u64 {
11950            if let Some(_) = self.remaining_key_lease_time_total {
11951                return 6;
11952            }
11953            if let Some(_) = self.remaining_lease_time_total {
11954                return 5;
11955            }
11956            if let Some(_) = self.key_lease_time_total {
11957                return 4;
11958            }
11959            if let Some(_) = self.lease_time_total {
11960                return 3;
11961            }
11962            if let Some(_) = self.deleted_count {
11963                return 2;
11964            }
11965            if let Some(_) = self.fresh_count {
11966                return 1;
11967            }
11968            0
11969        }
11970    }
11971
11972    impl fidl::encoding::ValueTypeMarker for SrpServerRegistration {
11973        type Borrowed<'a> = &'a Self;
11974        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
11975            value
11976        }
11977    }
11978
11979    unsafe impl fidl::encoding::TypeMarker for SrpServerRegistration {
11980        type Owned = Self;
11981
11982        #[inline(always)]
11983        fn inline_align(_context: fidl::encoding::Context) -> usize {
11984            8
11985        }
11986
11987        #[inline(always)]
11988        fn inline_size(_context: fidl::encoding::Context) -> usize {
11989            16
11990        }
11991    }
11992
11993    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SrpServerRegistration, D>
11994        for &SrpServerRegistration
11995    {
11996        unsafe fn encode(
11997            self,
11998            encoder: &mut fidl::encoding::Encoder<'_, D>,
11999            offset: usize,
12000            mut depth: fidl::encoding::Depth,
12001        ) -> fidl::Result<()> {
12002            encoder.debug_check_bounds::<SrpServerRegistration>(offset);
12003            // Vector header
12004            let max_ordinal: u64 = self.max_ordinal_present();
12005            encoder.write_num(max_ordinal, offset);
12006            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12007            // Calling encoder.out_of_line_offset(0) is not allowed.
12008            if max_ordinal == 0 {
12009                return Ok(());
12010            }
12011            depth.increment()?;
12012            let envelope_size = 8;
12013            let bytes_len = max_ordinal as usize * envelope_size;
12014            #[allow(unused_variables)]
12015            let offset = encoder.out_of_line_offset(bytes_len);
12016            let mut _prev_end_offset: usize = 0;
12017            if 1 > max_ordinal {
12018                return Ok(());
12019            }
12020
12021            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12022            // are envelope_size bytes.
12023            let cur_offset: usize = (1 - 1) * envelope_size;
12024
12025            // Zero reserved fields.
12026            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12027
12028            // Safety:
12029            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12030            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12031            //   envelope_size bytes, there is always sufficient room.
12032            fidl::encoding::encode_in_envelope_optional::<u32, D>(
12033                self.fresh_count.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12034                encoder,
12035                offset + cur_offset,
12036                depth,
12037            )?;
12038
12039            _prev_end_offset = cur_offset + envelope_size;
12040            if 2 > max_ordinal {
12041                return Ok(());
12042            }
12043
12044            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12045            // are envelope_size bytes.
12046            let cur_offset: usize = (2 - 1) * envelope_size;
12047
12048            // Zero reserved fields.
12049            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12050
12051            // Safety:
12052            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12053            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12054            //   envelope_size bytes, there is always sufficient room.
12055            fidl::encoding::encode_in_envelope_optional::<u32, D>(
12056                self.deleted_count.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12057                encoder,
12058                offset + cur_offset,
12059                depth,
12060            )?;
12061
12062            _prev_end_offset = cur_offset + envelope_size;
12063            if 3 > max_ordinal {
12064                return Ok(());
12065            }
12066
12067            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12068            // are envelope_size bytes.
12069            let cur_offset: usize = (3 - 1) * envelope_size;
12070
12071            // Zero reserved fields.
12072            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12073
12074            // Safety:
12075            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12076            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12077            //   envelope_size bytes, there is always sufficient room.
12078            fidl::encoding::encode_in_envelope_optional::<i64, D>(
12079                self.lease_time_total
12080                    .as_ref()
12081                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
12082                encoder,
12083                offset + cur_offset,
12084                depth,
12085            )?;
12086
12087            _prev_end_offset = cur_offset + envelope_size;
12088            if 4 > max_ordinal {
12089                return Ok(());
12090            }
12091
12092            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12093            // are envelope_size bytes.
12094            let cur_offset: usize = (4 - 1) * envelope_size;
12095
12096            // Zero reserved fields.
12097            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12098
12099            // Safety:
12100            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12101            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12102            //   envelope_size bytes, there is always sufficient room.
12103            fidl::encoding::encode_in_envelope_optional::<i64, D>(
12104                self.key_lease_time_total
12105                    .as_ref()
12106                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
12107                encoder,
12108                offset + cur_offset,
12109                depth,
12110            )?;
12111
12112            _prev_end_offset = cur_offset + envelope_size;
12113            if 5 > max_ordinal {
12114                return Ok(());
12115            }
12116
12117            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12118            // are envelope_size bytes.
12119            let cur_offset: usize = (5 - 1) * envelope_size;
12120
12121            // Zero reserved fields.
12122            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12123
12124            // Safety:
12125            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12126            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12127            //   envelope_size bytes, there is always sufficient room.
12128            fidl::encoding::encode_in_envelope_optional::<i64, D>(
12129                self.remaining_lease_time_total
12130                    .as_ref()
12131                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
12132                encoder,
12133                offset + cur_offset,
12134                depth,
12135            )?;
12136
12137            _prev_end_offset = cur_offset + envelope_size;
12138            if 6 > max_ordinal {
12139                return Ok(());
12140            }
12141
12142            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12143            // are envelope_size bytes.
12144            let cur_offset: usize = (6 - 1) * envelope_size;
12145
12146            // Zero reserved fields.
12147            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12148
12149            // Safety:
12150            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12151            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12152            //   envelope_size bytes, there is always sufficient room.
12153            fidl::encoding::encode_in_envelope_optional::<i64, D>(
12154                self.remaining_key_lease_time_total
12155                    .as_ref()
12156                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
12157                encoder,
12158                offset + cur_offset,
12159                depth,
12160            )?;
12161
12162            _prev_end_offset = cur_offset + envelope_size;
12163
12164            Ok(())
12165        }
12166    }
12167
12168    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SrpServerRegistration {
12169        #[inline(always)]
12170        fn new_empty() -> Self {
12171            Self::default()
12172        }
12173
12174        unsafe fn decode(
12175            &mut self,
12176            decoder: &mut fidl::encoding::Decoder<'_, D>,
12177            offset: usize,
12178            mut depth: fidl::encoding::Depth,
12179        ) -> fidl::Result<()> {
12180            decoder.debug_check_bounds::<Self>(offset);
12181            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12182                None => return Err(fidl::Error::NotNullable),
12183                Some(len) => len,
12184            };
12185            // Calling decoder.out_of_line_offset(0) is not allowed.
12186            if len == 0 {
12187                return Ok(());
12188            };
12189            depth.increment()?;
12190            let envelope_size = 8;
12191            let bytes_len = len * envelope_size;
12192            let offset = decoder.out_of_line_offset(bytes_len)?;
12193            // Decode the envelope for each type.
12194            let mut _next_ordinal_to_read = 0;
12195            let mut next_offset = offset;
12196            let end_offset = offset + bytes_len;
12197            _next_ordinal_to_read += 1;
12198            if next_offset >= end_offset {
12199                return Ok(());
12200            }
12201
12202            // Decode unknown envelopes for gaps in ordinals.
12203            while _next_ordinal_to_read < 1 {
12204                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12205                _next_ordinal_to_read += 1;
12206                next_offset += envelope_size;
12207            }
12208
12209            let next_out_of_line = decoder.next_out_of_line();
12210            let handles_before = decoder.remaining_handles();
12211            if let Some((inlined, num_bytes, num_handles)) =
12212                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12213            {
12214                let member_inline_size =
12215                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12216                if inlined != (member_inline_size <= 4) {
12217                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12218                }
12219                let inner_offset;
12220                let mut inner_depth = depth.clone();
12221                if inlined {
12222                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12223                    inner_offset = next_offset;
12224                } else {
12225                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12226                    inner_depth.increment()?;
12227                }
12228                let val_ref = self.fresh_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
12229                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12230                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12231                {
12232                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12233                }
12234                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12235                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12236                }
12237            }
12238
12239            next_offset += envelope_size;
12240            _next_ordinal_to_read += 1;
12241            if next_offset >= end_offset {
12242                return Ok(());
12243            }
12244
12245            // Decode unknown envelopes for gaps in ordinals.
12246            while _next_ordinal_to_read < 2 {
12247                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12248                _next_ordinal_to_read += 1;
12249                next_offset += envelope_size;
12250            }
12251
12252            let next_out_of_line = decoder.next_out_of_line();
12253            let handles_before = decoder.remaining_handles();
12254            if let Some((inlined, num_bytes, num_handles)) =
12255                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12256            {
12257                let member_inline_size =
12258                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12259                if inlined != (member_inline_size <= 4) {
12260                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12261                }
12262                let inner_offset;
12263                let mut inner_depth = depth.clone();
12264                if inlined {
12265                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12266                    inner_offset = next_offset;
12267                } else {
12268                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12269                    inner_depth.increment()?;
12270                }
12271                let val_ref = self.deleted_count.get_or_insert_with(|| fidl::new_empty!(u32, D));
12272                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12273                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12274                {
12275                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12276                }
12277                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12278                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12279                }
12280            }
12281
12282            next_offset += envelope_size;
12283            _next_ordinal_to_read += 1;
12284            if next_offset >= end_offset {
12285                return Ok(());
12286            }
12287
12288            // Decode unknown envelopes for gaps in ordinals.
12289            while _next_ordinal_to_read < 3 {
12290                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12291                _next_ordinal_to_read += 1;
12292                next_offset += envelope_size;
12293            }
12294
12295            let next_out_of_line = decoder.next_out_of_line();
12296            let handles_before = decoder.remaining_handles();
12297            if let Some((inlined, num_bytes, num_handles)) =
12298                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12299            {
12300                let member_inline_size =
12301                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12302                if inlined != (member_inline_size <= 4) {
12303                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12304                }
12305                let inner_offset;
12306                let mut inner_depth = depth.clone();
12307                if inlined {
12308                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12309                    inner_offset = next_offset;
12310                } else {
12311                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12312                    inner_depth.increment()?;
12313                }
12314                let val_ref = self.lease_time_total.get_or_insert_with(|| fidl::new_empty!(i64, D));
12315                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
12316                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12317                {
12318                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12319                }
12320                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12321                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12322                }
12323            }
12324
12325            next_offset += envelope_size;
12326            _next_ordinal_to_read += 1;
12327            if next_offset >= end_offset {
12328                return Ok(());
12329            }
12330
12331            // Decode unknown envelopes for gaps in ordinals.
12332            while _next_ordinal_to_read < 4 {
12333                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12334                _next_ordinal_to_read += 1;
12335                next_offset += envelope_size;
12336            }
12337
12338            let next_out_of_line = decoder.next_out_of_line();
12339            let handles_before = decoder.remaining_handles();
12340            if let Some((inlined, num_bytes, num_handles)) =
12341                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12342            {
12343                let member_inline_size =
12344                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12345                if inlined != (member_inline_size <= 4) {
12346                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12347                }
12348                let inner_offset;
12349                let mut inner_depth = depth.clone();
12350                if inlined {
12351                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12352                    inner_offset = next_offset;
12353                } else {
12354                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12355                    inner_depth.increment()?;
12356                }
12357                let val_ref =
12358                    self.key_lease_time_total.get_or_insert_with(|| fidl::new_empty!(i64, D));
12359                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
12360                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12361                {
12362                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12363                }
12364                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12365                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12366                }
12367            }
12368
12369            next_offset += envelope_size;
12370            _next_ordinal_to_read += 1;
12371            if next_offset >= end_offset {
12372                return Ok(());
12373            }
12374
12375            // Decode unknown envelopes for gaps in ordinals.
12376            while _next_ordinal_to_read < 5 {
12377                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12378                _next_ordinal_to_read += 1;
12379                next_offset += envelope_size;
12380            }
12381
12382            let next_out_of_line = decoder.next_out_of_line();
12383            let handles_before = decoder.remaining_handles();
12384            if let Some((inlined, num_bytes, num_handles)) =
12385                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12386            {
12387                let member_inline_size =
12388                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12389                if inlined != (member_inline_size <= 4) {
12390                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12391                }
12392                let inner_offset;
12393                let mut inner_depth = depth.clone();
12394                if inlined {
12395                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12396                    inner_offset = next_offset;
12397                } else {
12398                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12399                    inner_depth.increment()?;
12400                }
12401                let val_ref =
12402                    self.remaining_lease_time_total.get_or_insert_with(|| fidl::new_empty!(i64, D));
12403                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
12404                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12405                {
12406                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12407                }
12408                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12409                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12410                }
12411            }
12412
12413            next_offset += envelope_size;
12414            _next_ordinal_to_read += 1;
12415            if next_offset >= end_offset {
12416                return Ok(());
12417            }
12418
12419            // Decode unknown envelopes for gaps in ordinals.
12420            while _next_ordinal_to_read < 6 {
12421                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12422                _next_ordinal_to_read += 1;
12423                next_offset += envelope_size;
12424            }
12425
12426            let next_out_of_line = decoder.next_out_of_line();
12427            let handles_before = decoder.remaining_handles();
12428            if let Some((inlined, num_bytes, num_handles)) =
12429                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12430            {
12431                let member_inline_size =
12432                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12433                if inlined != (member_inline_size <= 4) {
12434                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12435                }
12436                let inner_offset;
12437                let mut inner_depth = depth.clone();
12438                if inlined {
12439                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12440                    inner_offset = next_offset;
12441                } else {
12442                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12443                    inner_depth.increment()?;
12444                }
12445                let val_ref = self
12446                    .remaining_key_lease_time_total
12447                    .get_or_insert_with(|| fidl::new_empty!(i64, D));
12448                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
12449                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12450                {
12451                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12452                }
12453                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12454                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12455                }
12456            }
12457
12458            next_offset += envelope_size;
12459
12460            // Decode the remaining unknown envelopes.
12461            while next_offset < end_offset {
12462                _next_ordinal_to_read += 1;
12463                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12464                next_offset += envelope_size;
12465            }
12466
12467            Ok(())
12468        }
12469    }
12470
12471    impl SrpServerResponseCounters {
12472        #[inline(always)]
12473        fn max_ordinal_present(&self) -> u64 {
12474            if let Some(_) = self.other_response {
12475                return 6;
12476            }
12477            if let Some(_) = self.refused_response {
12478                return 5;
12479            }
12480            if let Some(_) = self.name_exists_response {
12481                return 4;
12482            }
12483            if let Some(_) = self.format_error_response {
12484                return 3;
12485            }
12486            if let Some(_) = self.server_failure_response {
12487                return 2;
12488            }
12489            if let Some(_) = self.success_response {
12490                return 1;
12491            }
12492            0
12493        }
12494    }
12495
12496    impl fidl::encoding::ValueTypeMarker for SrpServerResponseCounters {
12497        type Borrowed<'a> = &'a Self;
12498        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
12499            value
12500        }
12501    }
12502
12503    unsafe impl fidl::encoding::TypeMarker for SrpServerResponseCounters {
12504        type Owned = Self;
12505
12506        #[inline(always)]
12507        fn inline_align(_context: fidl::encoding::Context) -> usize {
12508            8
12509        }
12510
12511        #[inline(always)]
12512        fn inline_size(_context: fidl::encoding::Context) -> usize {
12513            16
12514        }
12515    }
12516
12517    unsafe impl<D: fidl::encoding::ResourceDialect>
12518        fidl::encoding::Encode<SrpServerResponseCounters, D> for &SrpServerResponseCounters
12519    {
12520        unsafe fn encode(
12521            self,
12522            encoder: &mut fidl::encoding::Encoder<'_, D>,
12523            offset: usize,
12524            mut depth: fidl::encoding::Depth,
12525        ) -> fidl::Result<()> {
12526            encoder.debug_check_bounds::<SrpServerResponseCounters>(offset);
12527            // Vector header
12528            let max_ordinal: u64 = self.max_ordinal_present();
12529            encoder.write_num(max_ordinal, offset);
12530            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
12531            // Calling encoder.out_of_line_offset(0) is not allowed.
12532            if max_ordinal == 0 {
12533                return Ok(());
12534            }
12535            depth.increment()?;
12536            let envelope_size = 8;
12537            let bytes_len = max_ordinal as usize * envelope_size;
12538            #[allow(unused_variables)]
12539            let offset = encoder.out_of_line_offset(bytes_len);
12540            let mut _prev_end_offset: usize = 0;
12541            if 1 > max_ordinal {
12542                return Ok(());
12543            }
12544
12545            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12546            // are envelope_size bytes.
12547            let cur_offset: usize = (1 - 1) * envelope_size;
12548
12549            // Zero reserved fields.
12550            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12551
12552            // Safety:
12553            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12554            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12555            //   envelope_size bytes, there is always sufficient room.
12556            fidl::encoding::encode_in_envelope_optional::<u32, D>(
12557                self.success_response
12558                    .as_ref()
12559                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12560                encoder,
12561                offset + cur_offset,
12562                depth,
12563            )?;
12564
12565            _prev_end_offset = cur_offset + envelope_size;
12566            if 2 > max_ordinal {
12567                return Ok(());
12568            }
12569
12570            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12571            // are envelope_size bytes.
12572            let cur_offset: usize = (2 - 1) * envelope_size;
12573
12574            // Zero reserved fields.
12575            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12576
12577            // Safety:
12578            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12579            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12580            //   envelope_size bytes, there is always sufficient room.
12581            fidl::encoding::encode_in_envelope_optional::<u32, D>(
12582                self.server_failure_response
12583                    .as_ref()
12584                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12585                encoder,
12586                offset + cur_offset,
12587                depth,
12588            )?;
12589
12590            _prev_end_offset = cur_offset + envelope_size;
12591            if 3 > max_ordinal {
12592                return Ok(());
12593            }
12594
12595            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12596            // are envelope_size bytes.
12597            let cur_offset: usize = (3 - 1) * envelope_size;
12598
12599            // Zero reserved fields.
12600            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12601
12602            // Safety:
12603            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12604            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12605            //   envelope_size bytes, there is always sufficient room.
12606            fidl::encoding::encode_in_envelope_optional::<u32, D>(
12607                self.format_error_response
12608                    .as_ref()
12609                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12610                encoder,
12611                offset + cur_offset,
12612                depth,
12613            )?;
12614
12615            _prev_end_offset = cur_offset + envelope_size;
12616            if 4 > max_ordinal {
12617                return Ok(());
12618            }
12619
12620            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12621            // are envelope_size bytes.
12622            let cur_offset: usize = (4 - 1) * envelope_size;
12623
12624            // Zero reserved fields.
12625            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12626
12627            // Safety:
12628            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12629            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12630            //   envelope_size bytes, there is always sufficient room.
12631            fidl::encoding::encode_in_envelope_optional::<u32, D>(
12632                self.name_exists_response
12633                    .as_ref()
12634                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12635                encoder,
12636                offset + cur_offset,
12637                depth,
12638            )?;
12639
12640            _prev_end_offset = cur_offset + envelope_size;
12641            if 5 > max_ordinal {
12642                return Ok(());
12643            }
12644
12645            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12646            // are envelope_size bytes.
12647            let cur_offset: usize = (5 - 1) * envelope_size;
12648
12649            // Zero reserved fields.
12650            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12651
12652            // Safety:
12653            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12654            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12655            //   envelope_size bytes, there is always sufficient room.
12656            fidl::encoding::encode_in_envelope_optional::<u32, D>(
12657                self.refused_response
12658                    .as_ref()
12659                    .map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12660                encoder,
12661                offset + cur_offset,
12662                depth,
12663            )?;
12664
12665            _prev_end_offset = cur_offset + envelope_size;
12666            if 6 > max_ordinal {
12667                return Ok(());
12668            }
12669
12670            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
12671            // are envelope_size bytes.
12672            let cur_offset: usize = (6 - 1) * envelope_size;
12673
12674            // Zero reserved fields.
12675            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
12676
12677            // Safety:
12678            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
12679            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
12680            //   envelope_size bytes, there is always sufficient room.
12681            fidl::encoding::encode_in_envelope_optional::<u32, D>(
12682                self.other_response.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
12683                encoder,
12684                offset + cur_offset,
12685                depth,
12686            )?;
12687
12688            _prev_end_offset = cur_offset + envelope_size;
12689
12690            Ok(())
12691        }
12692    }
12693
12694    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
12695        for SrpServerResponseCounters
12696    {
12697        #[inline(always)]
12698        fn new_empty() -> Self {
12699            Self::default()
12700        }
12701
12702        unsafe fn decode(
12703            &mut self,
12704            decoder: &mut fidl::encoding::Decoder<'_, D>,
12705            offset: usize,
12706            mut depth: fidl::encoding::Depth,
12707        ) -> fidl::Result<()> {
12708            decoder.debug_check_bounds::<Self>(offset);
12709            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
12710                None => return Err(fidl::Error::NotNullable),
12711                Some(len) => len,
12712            };
12713            // Calling decoder.out_of_line_offset(0) is not allowed.
12714            if len == 0 {
12715                return Ok(());
12716            };
12717            depth.increment()?;
12718            let envelope_size = 8;
12719            let bytes_len = len * envelope_size;
12720            let offset = decoder.out_of_line_offset(bytes_len)?;
12721            // Decode the envelope for each type.
12722            let mut _next_ordinal_to_read = 0;
12723            let mut next_offset = offset;
12724            let end_offset = offset + bytes_len;
12725            _next_ordinal_to_read += 1;
12726            if next_offset >= end_offset {
12727                return Ok(());
12728            }
12729
12730            // Decode unknown envelopes for gaps in ordinals.
12731            while _next_ordinal_to_read < 1 {
12732                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12733                _next_ordinal_to_read += 1;
12734                next_offset += envelope_size;
12735            }
12736
12737            let next_out_of_line = decoder.next_out_of_line();
12738            let handles_before = decoder.remaining_handles();
12739            if let Some((inlined, num_bytes, num_handles)) =
12740                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12741            {
12742                let member_inline_size =
12743                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12744                if inlined != (member_inline_size <= 4) {
12745                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12746                }
12747                let inner_offset;
12748                let mut inner_depth = depth.clone();
12749                if inlined {
12750                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12751                    inner_offset = next_offset;
12752                } else {
12753                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12754                    inner_depth.increment()?;
12755                }
12756                let val_ref = self.success_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12757                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12758                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12759                {
12760                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12761                }
12762                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12763                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12764                }
12765            }
12766
12767            next_offset += envelope_size;
12768            _next_ordinal_to_read += 1;
12769            if next_offset >= end_offset {
12770                return Ok(());
12771            }
12772
12773            // Decode unknown envelopes for gaps in ordinals.
12774            while _next_ordinal_to_read < 2 {
12775                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12776                _next_ordinal_to_read += 1;
12777                next_offset += envelope_size;
12778            }
12779
12780            let next_out_of_line = decoder.next_out_of_line();
12781            let handles_before = decoder.remaining_handles();
12782            if let Some((inlined, num_bytes, num_handles)) =
12783                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12784            {
12785                let member_inline_size =
12786                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12787                if inlined != (member_inline_size <= 4) {
12788                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12789                }
12790                let inner_offset;
12791                let mut inner_depth = depth.clone();
12792                if inlined {
12793                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12794                    inner_offset = next_offset;
12795                } else {
12796                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12797                    inner_depth.increment()?;
12798                }
12799                let val_ref =
12800                    self.server_failure_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12801                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12802                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12803                {
12804                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12805                }
12806                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12807                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12808                }
12809            }
12810
12811            next_offset += envelope_size;
12812            _next_ordinal_to_read += 1;
12813            if next_offset >= end_offset {
12814                return Ok(());
12815            }
12816
12817            // Decode unknown envelopes for gaps in ordinals.
12818            while _next_ordinal_to_read < 3 {
12819                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12820                _next_ordinal_to_read += 1;
12821                next_offset += envelope_size;
12822            }
12823
12824            let next_out_of_line = decoder.next_out_of_line();
12825            let handles_before = decoder.remaining_handles();
12826            if let Some((inlined, num_bytes, num_handles)) =
12827                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12828            {
12829                let member_inline_size =
12830                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12831                if inlined != (member_inline_size <= 4) {
12832                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12833                }
12834                let inner_offset;
12835                let mut inner_depth = depth.clone();
12836                if inlined {
12837                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12838                    inner_offset = next_offset;
12839                } else {
12840                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12841                    inner_depth.increment()?;
12842                }
12843                let val_ref =
12844                    self.format_error_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12845                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12846                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12847                {
12848                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12849                }
12850                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12851                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12852                }
12853            }
12854
12855            next_offset += envelope_size;
12856            _next_ordinal_to_read += 1;
12857            if next_offset >= end_offset {
12858                return Ok(());
12859            }
12860
12861            // Decode unknown envelopes for gaps in ordinals.
12862            while _next_ordinal_to_read < 4 {
12863                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12864                _next_ordinal_to_read += 1;
12865                next_offset += envelope_size;
12866            }
12867
12868            let next_out_of_line = decoder.next_out_of_line();
12869            let handles_before = decoder.remaining_handles();
12870            if let Some((inlined, num_bytes, num_handles)) =
12871                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12872            {
12873                let member_inline_size =
12874                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12875                if inlined != (member_inline_size <= 4) {
12876                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12877                }
12878                let inner_offset;
12879                let mut inner_depth = depth.clone();
12880                if inlined {
12881                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12882                    inner_offset = next_offset;
12883                } else {
12884                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12885                    inner_depth.increment()?;
12886                }
12887                let val_ref =
12888                    self.name_exists_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12889                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12890                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12891                {
12892                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12893                }
12894                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12895                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12896                }
12897            }
12898
12899            next_offset += envelope_size;
12900            _next_ordinal_to_read += 1;
12901            if next_offset >= end_offset {
12902                return Ok(());
12903            }
12904
12905            // Decode unknown envelopes for gaps in ordinals.
12906            while _next_ordinal_to_read < 5 {
12907                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12908                _next_ordinal_to_read += 1;
12909                next_offset += envelope_size;
12910            }
12911
12912            let next_out_of_line = decoder.next_out_of_line();
12913            let handles_before = decoder.remaining_handles();
12914            if let Some((inlined, num_bytes, num_handles)) =
12915                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12916            {
12917                let member_inline_size =
12918                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12919                if inlined != (member_inline_size <= 4) {
12920                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12921                }
12922                let inner_offset;
12923                let mut inner_depth = depth.clone();
12924                if inlined {
12925                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12926                    inner_offset = next_offset;
12927                } else {
12928                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12929                    inner_depth.increment()?;
12930                }
12931                let val_ref = self.refused_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12932                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12933                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12934                {
12935                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12936                }
12937                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12938                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12939                }
12940            }
12941
12942            next_offset += envelope_size;
12943            _next_ordinal_to_read += 1;
12944            if next_offset >= end_offset {
12945                return Ok(());
12946            }
12947
12948            // Decode unknown envelopes for gaps in ordinals.
12949            while _next_ordinal_to_read < 6 {
12950                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12951                _next_ordinal_to_read += 1;
12952                next_offset += envelope_size;
12953            }
12954
12955            let next_out_of_line = decoder.next_out_of_line();
12956            let handles_before = decoder.remaining_handles();
12957            if let Some((inlined, num_bytes, num_handles)) =
12958                fidl::encoding::decode_envelope_header(decoder, next_offset)?
12959            {
12960                let member_inline_size =
12961                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
12962                if inlined != (member_inline_size <= 4) {
12963                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
12964                }
12965                let inner_offset;
12966                let mut inner_depth = depth.clone();
12967                if inlined {
12968                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
12969                    inner_offset = next_offset;
12970                } else {
12971                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
12972                    inner_depth.increment()?;
12973                }
12974                let val_ref = self.other_response.get_or_insert_with(|| fidl::new_empty!(u32, D));
12975                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
12976                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
12977                {
12978                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
12979                }
12980                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
12981                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
12982                }
12983            }
12984
12985            next_offset += envelope_size;
12986
12987            // Decode the remaining unknown envelopes.
12988            while next_offset < end_offset {
12989                _next_ordinal_to_read += 1;
12990                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
12991                next_offset += envelope_size;
12992            }
12993
12994            Ok(())
12995        }
12996    }
12997
12998    impl Telemetry {
12999        #[inline(always)]
13000        fn max_ordinal_present(&self) -> u64 {
13001            if let Some(_) = self.link_metrics_entries {
13002                return 24;
13003            }
13004            if let Some(_) = self.dhcp6pd_info {
13005                return 23;
13006            }
13007            if let Some(_) = self.upstream_dns_info {
13008                return 22;
13009            }
13010            if let Some(_) = self.trel_peers_info {
13011                return 21;
13012            }
13013            if let Some(_) = self.trel_counters {
13014                return 20;
13015            }
13016            if let Some(_) = self.nat64_info {
13017                return 19;
13018            }
13019            if let Some(_) = self.uptime {
13020                return 18;
13021            }
13022            if let Some(_) = self.leader_data {
13023                return 17;
13024            }
13025            if let Some(_) = self.dnssd_counters {
13026                return 16;
13027            }
13028            if let Some(_) = self.srp_server_info {
13029                return 15;
13030            }
13031            if let Some(_) = self.thread_border_routing_counters {
13032                return 14;
13033            }
13034            if let Some(_) = self.thread_stable_network_data {
13035                return 13;
13036            }
13037            if let Some(_) = self.thread_network_data {
13038                return 12;
13039            }
13040            if let Some(_) = self.thread_stable_network_data_version {
13041                return 11;
13042            }
13043            if let Some(_) = self.thread_network_data_version {
13044                return 10;
13045            }
13046            if let Some(_) = self.thread_rloc {
13047                return 9;
13048            }
13049            if let Some(_) = self.thread_router_id {
13050                return 8;
13051            }
13052            if let Some(_) = self.thread_link_mode {
13053                return 7;
13054            }
13055            if let Some(_) = self.rcp_version {
13056                return 6;
13057            }
13058            if let Some(_) = self.stack_version {
13059                return 5;
13060            }
13061            if let Some(_) = self.partition_id {
13062                return 4;
13063            }
13064            if let Some(_) = self.channel_index {
13065                return 3;
13066            }
13067            if let Some(_) = self.tx_power {
13068                return 2;
13069            }
13070            if let Some(_) = self.rssi {
13071                return 1;
13072            }
13073            0
13074        }
13075    }
13076
13077    impl fidl::encoding::ValueTypeMarker for Telemetry {
13078        type Borrowed<'a> = &'a Self;
13079        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
13080            value
13081        }
13082    }
13083
13084    unsafe impl fidl::encoding::TypeMarker for Telemetry {
13085        type Owned = Self;
13086
13087        #[inline(always)]
13088        fn inline_align(_context: fidl::encoding::Context) -> usize {
13089            8
13090        }
13091
13092        #[inline(always)]
13093        fn inline_size(_context: fidl::encoding::Context) -> usize {
13094            16
13095        }
13096    }
13097
13098    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Telemetry, D>
13099        for &Telemetry
13100    {
13101        unsafe fn encode(
13102            self,
13103            encoder: &mut fidl::encoding::Encoder<'_, D>,
13104            offset: usize,
13105            mut depth: fidl::encoding::Depth,
13106        ) -> fidl::Result<()> {
13107            encoder.debug_check_bounds::<Telemetry>(offset);
13108            // Vector header
13109            let max_ordinal: u64 = self.max_ordinal_present();
13110            encoder.write_num(max_ordinal, offset);
13111            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
13112            // Calling encoder.out_of_line_offset(0) is not allowed.
13113            if max_ordinal == 0 {
13114                return Ok(());
13115            }
13116            depth.increment()?;
13117            let envelope_size = 8;
13118            let bytes_len = max_ordinal as usize * envelope_size;
13119            #[allow(unused_variables)]
13120            let offset = encoder.out_of_line_offset(bytes_len);
13121            let mut _prev_end_offset: usize = 0;
13122            if 1 > max_ordinal {
13123                return Ok(());
13124            }
13125
13126            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13127            // are envelope_size bytes.
13128            let cur_offset: usize = (1 - 1) * envelope_size;
13129
13130            // Zero reserved fields.
13131            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13132
13133            // Safety:
13134            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13135            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13136            //   envelope_size bytes, there is always sufficient room.
13137            fidl::encoding::encode_in_envelope_optional::<i8, D>(
13138                self.rssi.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
13139                encoder,
13140                offset + cur_offset,
13141                depth,
13142            )?;
13143
13144            _prev_end_offset = cur_offset + envelope_size;
13145            if 2 > max_ordinal {
13146                return Ok(());
13147            }
13148
13149            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13150            // are envelope_size bytes.
13151            let cur_offset: usize = (2 - 1) * envelope_size;
13152
13153            // Zero reserved fields.
13154            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13155
13156            // Safety:
13157            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13158            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13159            //   envelope_size bytes, there is always sufficient room.
13160            fidl::encoding::encode_in_envelope_optional::<i8, D>(
13161                self.tx_power.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
13162                encoder,
13163                offset + cur_offset,
13164                depth,
13165            )?;
13166
13167            _prev_end_offset = cur_offset + envelope_size;
13168            if 3 > max_ordinal {
13169                return Ok(());
13170            }
13171
13172            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13173            // are envelope_size bytes.
13174            let cur_offset: usize = (3 - 1) * envelope_size;
13175
13176            // Zero reserved fields.
13177            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13178
13179            // Safety:
13180            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13181            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13182            //   envelope_size bytes, there is always sufficient room.
13183            fidl::encoding::encode_in_envelope_optional::<u16, D>(
13184                self.channel_index.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
13185                encoder,
13186                offset + cur_offset,
13187                depth,
13188            )?;
13189
13190            _prev_end_offset = cur_offset + envelope_size;
13191            if 4 > max_ordinal {
13192                return Ok(());
13193            }
13194
13195            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13196            // are envelope_size bytes.
13197            let cur_offset: usize = (4 - 1) * envelope_size;
13198
13199            // Zero reserved fields.
13200            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13201
13202            // Safety:
13203            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13204            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13205            //   envelope_size bytes, there is always sufficient room.
13206            fidl::encoding::encode_in_envelope_optional::<u32, D>(
13207                self.partition_id.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
13208                encoder,
13209                offset + cur_offset,
13210                depth,
13211            )?;
13212
13213            _prev_end_offset = cur_offset + envelope_size;
13214            if 5 > max_ordinal {
13215                return Ok(());
13216            }
13217
13218            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13219            // are envelope_size bytes.
13220            let cur_offset: usize = (5 - 1) * envelope_size;
13221
13222            // Zero reserved fields.
13223            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13224
13225            // Safety:
13226            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13227            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13228            //   envelope_size bytes, there is always sufficient room.
13229            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
13230                self.stack_version.as_ref().map(
13231                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
13232                ),
13233                encoder,
13234                offset + cur_offset,
13235                depth,
13236            )?;
13237
13238            _prev_end_offset = cur_offset + envelope_size;
13239            if 6 > max_ordinal {
13240                return Ok(());
13241            }
13242
13243            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13244            // are envelope_size bytes.
13245            let cur_offset: usize = (6 - 1) * envelope_size;
13246
13247            // Zero reserved fields.
13248            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13249
13250            // Safety:
13251            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13252            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13253            //   envelope_size bytes, there is always sufficient room.
13254            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<256>, D>(
13255                self.rcp_version.as_ref().map(
13256                    <fidl::encoding::BoundedString<256> as fidl::encoding::ValueTypeMarker>::borrow,
13257                ),
13258                encoder,
13259                offset + cur_offset,
13260                depth,
13261            )?;
13262
13263            _prev_end_offset = cur_offset + envelope_size;
13264            if 7 > max_ordinal {
13265                return Ok(());
13266            }
13267
13268            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13269            // are envelope_size bytes.
13270            let cur_offset: usize = (7 - 1) * envelope_size;
13271
13272            // Zero reserved fields.
13273            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13274
13275            // Safety:
13276            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13277            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13278            //   envelope_size bytes, there is always sufficient room.
13279            fidl::encoding::encode_in_envelope_optional::<u8, D>(
13280                self.thread_link_mode.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
13281                encoder,
13282                offset + cur_offset,
13283                depth,
13284            )?;
13285
13286            _prev_end_offset = cur_offset + envelope_size;
13287            if 8 > max_ordinal {
13288                return Ok(());
13289            }
13290
13291            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13292            // are envelope_size bytes.
13293            let cur_offset: usize = (8 - 1) * envelope_size;
13294
13295            // Zero reserved fields.
13296            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13297
13298            // Safety:
13299            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13300            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13301            //   envelope_size bytes, there is always sufficient room.
13302            fidl::encoding::encode_in_envelope_optional::<u8, D>(
13303                self.thread_router_id.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
13304                encoder,
13305                offset + cur_offset,
13306                depth,
13307            )?;
13308
13309            _prev_end_offset = cur_offset + envelope_size;
13310            if 9 > max_ordinal {
13311                return Ok(());
13312            }
13313
13314            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13315            // are envelope_size bytes.
13316            let cur_offset: usize = (9 - 1) * envelope_size;
13317
13318            // Zero reserved fields.
13319            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13320
13321            // Safety:
13322            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13323            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13324            //   envelope_size bytes, there is always sufficient room.
13325            fidl::encoding::encode_in_envelope_optional::<u16, D>(
13326                self.thread_rloc.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
13327                encoder,
13328                offset + cur_offset,
13329                depth,
13330            )?;
13331
13332            _prev_end_offset = cur_offset + envelope_size;
13333            if 10 > max_ordinal {
13334                return Ok(());
13335            }
13336
13337            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13338            // are envelope_size bytes.
13339            let cur_offset: usize = (10 - 1) * envelope_size;
13340
13341            // Zero reserved fields.
13342            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13343
13344            // Safety:
13345            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13346            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13347            //   envelope_size bytes, there is always sufficient room.
13348            fidl::encoding::encode_in_envelope_optional::<u8, D>(
13349                self.thread_network_data_version
13350                    .as_ref()
13351                    .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
13352                encoder,
13353                offset + cur_offset,
13354                depth,
13355            )?;
13356
13357            _prev_end_offset = cur_offset + envelope_size;
13358            if 11 > max_ordinal {
13359                return Ok(());
13360            }
13361
13362            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13363            // are envelope_size bytes.
13364            let cur_offset: usize = (11 - 1) * envelope_size;
13365
13366            // Zero reserved fields.
13367            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13368
13369            // Safety:
13370            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13371            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13372            //   envelope_size bytes, there is always sufficient room.
13373            fidl::encoding::encode_in_envelope_optional::<u8, D>(
13374                self.thread_stable_network_data_version
13375                    .as_ref()
13376                    .map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
13377                encoder,
13378                offset + cur_offset,
13379                depth,
13380            )?;
13381
13382            _prev_end_offset = cur_offset + envelope_size;
13383            if 12 > max_ordinal {
13384                return Ok(());
13385            }
13386
13387            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13388            // are envelope_size bytes.
13389            let cur_offset: usize = (12 - 1) * envelope_size;
13390
13391            // Zero reserved fields.
13392            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13393
13394            // Safety:
13395            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13396            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13397            //   envelope_size bytes, there is always sufficient room.
13398            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 255>, D>(
13399                self.thread_network_data.as_ref().map(
13400                    <fidl::encoding::Vector<u8, 255> as fidl::encoding::ValueTypeMarker>::borrow,
13401                ),
13402                encoder,
13403                offset + cur_offset,
13404                depth,
13405            )?;
13406
13407            _prev_end_offset = cur_offset + envelope_size;
13408            if 13 > max_ordinal {
13409                return Ok(());
13410            }
13411
13412            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13413            // are envelope_size bytes.
13414            let cur_offset: usize = (13 - 1) * envelope_size;
13415
13416            // Zero reserved fields.
13417            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13418
13419            // Safety:
13420            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13421            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13422            //   envelope_size bytes, there is always sufficient room.
13423            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 255>, D>(
13424                self.thread_stable_network_data.as_ref().map(
13425                    <fidl::encoding::Vector<u8, 255> as fidl::encoding::ValueTypeMarker>::borrow,
13426                ),
13427                encoder,
13428                offset + cur_offset,
13429                depth,
13430            )?;
13431
13432            _prev_end_offset = cur_offset + envelope_size;
13433            if 14 > max_ordinal {
13434                return Ok(());
13435            }
13436
13437            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13438            // are envelope_size bytes.
13439            let cur_offset: usize = (14 - 1) * envelope_size;
13440
13441            // Zero reserved fields.
13442            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13443
13444            // Safety:
13445            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13446            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13447            //   envelope_size bytes, there is always sufficient room.
13448            fidl::encoding::encode_in_envelope_optional::<BorderRoutingCounters, D>(
13449                self.thread_border_routing_counters
13450                    .as_ref()
13451                    .map(<BorderRoutingCounters as fidl::encoding::ValueTypeMarker>::borrow),
13452                encoder,
13453                offset + cur_offset,
13454                depth,
13455            )?;
13456
13457            _prev_end_offset = cur_offset + envelope_size;
13458            if 15 > max_ordinal {
13459                return Ok(());
13460            }
13461
13462            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13463            // are envelope_size bytes.
13464            let cur_offset: usize = (15 - 1) * envelope_size;
13465
13466            // Zero reserved fields.
13467            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13468
13469            // Safety:
13470            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13471            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13472            //   envelope_size bytes, there is always sufficient room.
13473            fidl::encoding::encode_in_envelope_optional::<SrpServerInfo, D>(
13474                self.srp_server_info
13475                    .as_ref()
13476                    .map(<SrpServerInfo as fidl::encoding::ValueTypeMarker>::borrow),
13477                encoder,
13478                offset + cur_offset,
13479                depth,
13480            )?;
13481
13482            _prev_end_offset = cur_offset + envelope_size;
13483            if 16 > max_ordinal {
13484                return Ok(());
13485            }
13486
13487            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13488            // are envelope_size bytes.
13489            let cur_offset: usize = (16 - 1) * envelope_size;
13490
13491            // Zero reserved fields.
13492            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13493
13494            // Safety:
13495            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13496            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13497            //   envelope_size bytes, there is always sufficient room.
13498            fidl::encoding::encode_in_envelope_optional::<DnssdCounters, D>(
13499                self.dnssd_counters
13500                    .as_ref()
13501                    .map(<DnssdCounters as fidl::encoding::ValueTypeMarker>::borrow),
13502                encoder,
13503                offset + cur_offset,
13504                depth,
13505            )?;
13506
13507            _prev_end_offset = cur_offset + envelope_size;
13508            if 17 > max_ordinal {
13509                return Ok(());
13510            }
13511
13512            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13513            // are envelope_size bytes.
13514            let cur_offset: usize = (17 - 1) * envelope_size;
13515
13516            // Zero reserved fields.
13517            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13518
13519            // Safety:
13520            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13521            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13522            //   envelope_size bytes, there is always sufficient room.
13523            fidl::encoding::encode_in_envelope_optional::<LeaderData, D>(
13524                self.leader_data
13525                    .as_ref()
13526                    .map(<LeaderData as fidl::encoding::ValueTypeMarker>::borrow),
13527                encoder,
13528                offset + cur_offset,
13529                depth,
13530            )?;
13531
13532            _prev_end_offset = cur_offset + envelope_size;
13533            if 18 > max_ordinal {
13534                return Ok(());
13535            }
13536
13537            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13538            // are envelope_size bytes.
13539            let cur_offset: usize = (18 - 1) * envelope_size;
13540
13541            // Zero reserved fields.
13542            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13543
13544            // Safety:
13545            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13546            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13547            //   envelope_size bytes, there is always sufficient room.
13548            fidl::encoding::encode_in_envelope_optional::<i64, D>(
13549                self.uptime.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
13550                encoder,
13551                offset + cur_offset,
13552                depth,
13553            )?;
13554
13555            _prev_end_offset = cur_offset + envelope_size;
13556            if 19 > max_ordinal {
13557                return Ok(());
13558            }
13559
13560            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13561            // are envelope_size bytes.
13562            let cur_offset: usize = (19 - 1) * envelope_size;
13563
13564            // Zero reserved fields.
13565            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13566
13567            // Safety:
13568            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13569            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13570            //   envelope_size bytes, there is always sufficient room.
13571            fidl::encoding::encode_in_envelope_optional::<Nat64Info, D>(
13572                self.nat64_info
13573                    .as_ref()
13574                    .map(<Nat64Info as fidl::encoding::ValueTypeMarker>::borrow),
13575                encoder,
13576                offset + cur_offset,
13577                depth,
13578            )?;
13579
13580            _prev_end_offset = cur_offset + envelope_size;
13581            if 20 > max_ordinal {
13582                return Ok(());
13583            }
13584
13585            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13586            // are envelope_size bytes.
13587            let cur_offset: usize = (20 - 1) * envelope_size;
13588
13589            // Zero reserved fields.
13590            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13591
13592            // Safety:
13593            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13594            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13595            //   envelope_size bytes, there is always sufficient room.
13596            fidl::encoding::encode_in_envelope_optional::<TrelCounters, D>(
13597                self.trel_counters
13598                    .as_ref()
13599                    .map(<TrelCounters as fidl::encoding::ValueTypeMarker>::borrow),
13600                encoder,
13601                offset + cur_offset,
13602                depth,
13603            )?;
13604
13605            _prev_end_offset = cur_offset + envelope_size;
13606            if 21 > max_ordinal {
13607                return Ok(());
13608            }
13609
13610            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13611            // are envelope_size bytes.
13612            let cur_offset: usize = (21 - 1) * envelope_size;
13613
13614            // Zero reserved fields.
13615            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13616
13617            // Safety:
13618            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13619            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13620            //   envelope_size bytes, there is always sufficient room.
13621            fidl::encoding::encode_in_envelope_optional::<TrelPeersInfo, D>(
13622                self.trel_peers_info
13623                    .as_ref()
13624                    .map(<TrelPeersInfo as fidl::encoding::ValueTypeMarker>::borrow),
13625                encoder,
13626                offset + cur_offset,
13627                depth,
13628            )?;
13629
13630            _prev_end_offset = cur_offset + envelope_size;
13631            if 22 > max_ordinal {
13632                return Ok(());
13633            }
13634
13635            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13636            // are envelope_size bytes.
13637            let cur_offset: usize = (22 - 1) * envelope_size;
13638
13639            // Zero reserved fields.
13640            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13641
13642            // Safety:
13643            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13644            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13645            //   envelope_size bytes, there is always sufficient room.
13646            fidl::encoding::encode_in_envelope_optional::<UpstreamDnsInfo, D>(
13647                self.upstream_dns_info
13648                    .as_ref()
13649                    .map(<UpstreamDnsInfo as fidl::encoding::ValueTypeMarker>::borrow),
13650                encoder,
13651                offset + cur_offset,
13652                depth,
13653            )?;
13654
13655            _prev_end_offset = cur_offset + envelope_size;
13656            if 23 > max_ordinal {
13657                return Ok(());
13658            }
13659
13660            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13661            // are envelope_size bytes.
13662            let cur_offset: usize = (23 - 1) * envelope_size;
13663
13664            // Zero reserved fields.
13665            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13666
13667            // Safety:
13668            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13669            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13670            //   envelope_size bytes, there is always sufficient room.
13671            fidl::encoding::encode_in_envelope_optional::<Dhcp6PdInfo, D>(
13672                self.dhcp6pd_info
13673                    .as_ref()
13674                    .map(<Dhcp6PdInfo as fidl::encoding::ValueTypeMarker>::borrow),
13675                encoder,
13676                offset + cur_offset,
13677                depth,
13678            )?;
13679
13680            _prev_end_offset = cur_offset + envelope_size;
13681            if 24 > max_ordinal {
13682                return Ok(());
13683            }
13684
13685            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
13686            // are envelope_size bytes.
13687            let cur_offset: usize = (24 - 1) * envelope_size;
13688
13689            // Zero reserved fields.
13690            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
13691
13692            // Safety:
13693            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
13694            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
13695            //   envelope_size bytes, there is always sufficient room.
13696            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<LinkMetricsEntry, 64>, D>(
13697            self.link_metrics_entries.as_ref().map(<fidl::encoding::Vector<LinkMetricsEntry, 64> as fidl::encoding::ValueTypeMarker>::borrow),
13698            encoder, offset + cur_offset, depth
13699        )?;
13700
13701            _prev_end_offset = cur_offset + envelope_size;
13702
13703            Ok(())
13704        }
13705    }
13706
13707    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Telemetry {
13708        #[inline(always)]
13709        fn new_empty() -> Self {
13710            Self::default()
13711        }
13712
13713        unsafe fn decode(
13714            &mut self,
13715            decoder: &mut fidl::encoding::Decoder<'_, D>,
13716            offset: usize,
13717            mut depth: fidl::encoding::Depth,
13718        ) -> fidl::Result<()> {
13719            decoder.debug_check_bounds::<Self>(offset);
13720            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
13721                None => return Err(fidl::Error::NotNullable),
13722                Some(len) => len,
13723            };
13724            // Calling decoder.out_of_line_offset(0) is not allowed.
13725            if len == 0 {
13726                return Ok(());
13727            };
13728            depth.increment()?;
13729            let envelope_size = 8;
13730            let bytes_len = len * envelope_size;
13731            let offset = decoder.out_of_line_offset(bytes_len)?;
13732            // Decode the envelope for each type.
13733            let mut _next_ordinal_to_read = 0;
13734            let mut next_offset = offset;
13735            let end_offset = offset + bytes_len;
13736            _next_ordinal_to_read += 1;
13737            if next_offset >= end_offset {
13738                return Ok(());
13739            }
13740
13741            // Decode unknown envelopes for gaps in ordinals.
13742            while _next_ordinal_to_read < 1 {
13743                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13744                _next_ordinal_to_read += 1;
13745                next_offset += envelope_size;
13746            }
13747
13748            let next_out_of_line = decoder.next_out_of_line();
13749            let handles_before = decoder.remaining_handles();
13750            if let Some((inlined, num_bytes, num_handles)) =
13751                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13752            {
13753                let member_inline_size =
13754                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13755                if inlined != (member_inline_size <= 4) {
13756                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13757                }
13758                let inner_offset;
13759                let mut inner_depth = depth.clone();
13760                if inlined {
13761                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13762                    inner_offset = next_offset;
13763                } else {
13764                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13765                    inner_depth.increment()?;
13766                }
13767                let val_ref = self.rssi.get_or_insert_with(|| fidl::new_empty!(i8, D));
13768                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
13769                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13770                {
13771                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13772                }
13773                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13774                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13775                }
13776            }
13777
13778            next_offset += envelope_size;
13779            _next_ordinal_to_read += 1;
13780            if next_offset >= end_offset {
13781                return Ok(());
13782            }
13783
13784            // Decode unknown envelopes for gaps in ordinals.
13785            while _next_ordinal_to_read < 2 {
13786                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13787                _next_ordinal_to_read += 1;
13788                next_offset += envelope_size;
13789            }
13790
13791            let next_out_of_line = decoder.next_out_of_line();
13792            let handles_before = decoder.remaining_handles();
13793            if let Some((inlined, num_bytes, num_handles)) =
13794                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13795            {
13796                let member_inline_size =
13797                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13798                if inlined != (member_inline_size <= 4) {
13799                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13800                }
13801                let inner_offset;
13802                let mut inner_depth = depth.clone();
13803                if inlined {
13804                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13805                    inner_offset = next_offset;
13806                } else {
13807                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13808                    inner_depth.increment()?;
13809                }
13810                let val_ref = self.tx_power.get_or_insert_with(|| fidl::new_empty!(i8, D));
13811                fidl::decode!(i8, D, val_ref, decoder, inner_offset, inner_depth)?;
13812                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13813                {
13814                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13815                }
13816                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13817                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13818                }
13819            }
13820
13821            next_offset += envelope_size;
13822            _next_ordinal_to_read += 1;
13823            if next_offset >= end_offset {
13824                return Ok(());
13825            }
13826
13827            // Decode unknown envelopes for gaps in ordinals.
13828            while _next_ordinal_to_read < 3 {
13829                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13830                _next_ordinal_to_read += 1;
13831                next_offset += envelope_size;
13832            }
13833
13834            let next_out_of_line = decoder.next_out_of_line();
13835            let handles_before = decoder.remaining_handles();
13836            if let Some((inlined, num_bytes, num_handles)) =
13837                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13838            {
13839                let member_inline_size =
13840                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13841                if inlined != (member_inline_size <= 4) {
13842                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13843                }
13844                let inner_offset;
13845                let mut inner_depth = depth.clone();
13846                if inlined {
13847                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13848                    inner_offset = next_offset;
13849                } else {
13850                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13851                    inner_depth.increment()?;
13852                }
13853                let val_ref = self.channel_index.get_or_insert_with(|| fidl::new_empty!(u16, D));
13854                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
13855                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13856                {
13857                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13858                }
13859                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13860                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13861                }
13862            }
13863
13864            next_offset += envelope_size;
13865            _next_ordinal_to_read += 1;
13866            if next_offset >= end_offset {
13867                return Ok(());
13868            }
13869
13870            // Decode unknown envelopes for gaps in ordinals.
13871            while _next_ordinal_to_read < 4 {
13872                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13873                _next_ordinal_to_read += 1;
13874                next_offset += envelope_size;
13875            }
13876
13877            let next_out_of_line = decoder.next_out_of_line();
13878            let handles_before = decoder.remaining_handles();
13879            if let Some((inlined, num_bytes, num_handles)) =
13880                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13881            {
13882                let member_inline_size =
13883                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
13884                if inlined != (member_inline_size <= 4) {
13885                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13886                }
13887                let inner_offset;
13888                let mut inner_depth = depth.clone();
13889                if inlined {
13890                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13891                    inner_offset = next_offset;
13892                } else {
13893                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13894                    inner_depth.increment()?;
13895                }
13896                let val_ref = self.partition_id.get_or_insert_with(|| fidl::new_empty!(u32, D));
13897                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
13898                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13899                {
13900                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13901                }
13902                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13903                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13904                }
13905            }
13906
13907            next_offset += envelope_size;
13908            _next_ordinal_to_read += 1;
13909            if next_offset >= end_offset {
13910                return Ok(());
13911            }
13912
13913            // Decode unknown envelopes for gaps in ordinals.
13914            while _next_ordinal_to_read < 5 {
13915                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13916                _next_ordinal_to_read += 1;
13917                next_offset += envelope_size;
13918            }
13919
13920            let next_out_of_line = decoder.next_out_of_line();
13921            let handles_before = decoder.remaining_handles();
13922            if let Some((inlined, num_bytes, num_handles)) =
13923                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13924            {
13925                let member_inline_size =
13926                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
13927                        decoder.context,
13928                    );
13929                if inlined != (member_inline_size <= 4) {
13930                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13931                }
13932                let inner_offset;
13933                let mut inner_depth = depth.clone();
13934                if inlined {
13935                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13936                    inner_offset = next_offset;
13937                } else {
13938                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13939                    inner_depth.increment()?;
13940                }
13941                let val_ref = self
13942                    .stack_version
13943                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
13944                fidl::decode!(
13945                    fidl::encoding::BoundedString<256>,
13946                    D,
13947                    val_ref,
13948                    decoder,
13949                    inner_offset,
13950                    inner_depth
13951                )?;
13952                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
13953                {
13954                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
13955                }
13956                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
13957                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
13958                }
13959            }
13960
13961            next_offset += envelope_size;
13962            _next_ordinal_to_read += 1;
13963            if next_offset >= end_offset {
13964                return Ok(());
13965            }
13966
13967            // Decode unknown envelopes for gaps in ordinals.
13968            while _next_ordinal_to_read < 6 {
13969                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
13970                _next_ordinal_to_read += 1;
13971                next_offset += envelope_size;
13972            }
13973
13974            let next_out_of_line = decoder.next_out_of_line();
13975            let handles_before = decoder.remaining_handles();
13976            if let Some((inlined, num_bytes, num_handles)) =
13977                fidl::encoding::decode_envelope_header(decoder, next_offset)?
13978            {
13979                let member_inline_size =
13980                    <fidl::encoding::BoundedString<256> as fidl::encoding::TypeMarker>::inline_size(
13981                        decoder.context,
13982                    );
13983                if inlined != (member_inline_size <= 4) {
13984                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
13985                }
13986                let inner_offset;
13987                let mut inner_depth = depth.clone();
13988                if inlined {
13989                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
13990                    inner_offset = next_offset;
13991                } else {
13992                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
13993                    inner_depth.increment()?;
13994                }
13995                let val_ref = self
13996                    .rcp_version
13997                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<256>, D));
13998                fidl::decode!(
13999                    fidl::encoding::BoundedString<256>,
14000                    D,
14001                    val_ref,
14002                    decoder,
14003                    inner_offset,
14004                    inner_depth
14005                )?;
14006                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14007                {
14008                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14009                }
14010                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14011                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14012                }
14013            }
14014
14015            next_offset += envelope_size;
14016            _next_ordinal_to_read += 1;
14017            if next_offset >= end_offset {
14018                return Ok(());
14019            }
14020
14021            // Decode unknown envelopes for gaps in ordinals.
14022            while _next_ordinal_to_read < 7 {
14023                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14024                _next_ordinal_to_read += 1;
14025                next_offset += envelope_size;
14026            }
14027
14028            let next_out_of_line = decoder.next_out_of_line();
14029            let handles_before = decoder.remaining_handles();
14030            if let Some((inlined, num_bytes, num_handles)) =
14031                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14032            {
14033                let member_inline_size =
14034                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14035                if inlined != (member_inline_size <= 4) {
14036                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14037                }
14038                let inner_offset;
14039                let mut inner_depth = depth.clone();
14040                if inlined {
14041                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14042                    inner_offset = next_offset;
14043                } else {
14044                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14045                    inner_depth.increment()?;
14046                }
14047                let val_ref = self.thread_link_mode.get_or_insert_with(|| fidl::new_empty!(u8, D));
14048                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
14049                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14050                {
14051                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14052                }
14053                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14054                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14055                }
14056            }
14057
14058            next_offset += envelope_size;
14059            _next_ordinal_to_read += 1;
14060            if next_offset >= end_offset {
14061                return Ok(());
14062            }
14063
14064            // Decode unknown envelopes for gaps in ordinals.
14065            while _next_ordinal_to_read < 8 {
14066                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14067                _next_ordinal_to_read += 1;
14068                next_offset += envelope_size;
14069            }
14070
14071            let next_out_of_line = decoder.next_out_of_line();
14072            let handles_before = decoder.remaining_handles();
14073            if let Some((inlined, num_bytes, num_handles)) =
14074                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14075            {
14076                let member_inline_size =
14077                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14078                if inlined != (member_inline_size <= 4) {
14079                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14080                }
14081                let inner_offset;
14082                let mut inner_depth = depth.clone();
14083                if inlined {
14084                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14085                    inner_offset = next_offset;
14086                } else {
14087                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14088                    inner_depth.increment()?;
14089                }
14090                let val_ref = self.thread_router_id.get_or_insert_with(|| fidl::new_empty!(u8, D));
14091                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
14092                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14093                {
14094                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14095                }
14096                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14097                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14098                }
14099            }
14100
14101            next_offset += envelope_size;
14102            _next_ordinal_to_read += 1;
14103            if next_offset >= end_offset {
14104                return Ok(());
14105            }
14106
14107            // Decode unknown envelopes for gaps in ordinals.
14108            while _next_ordinal_to_read < 9 {
14109                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14110                _next_ordinal_to_read += 1;
14111                next_offset += envelope_size;
14112            }
14113
14114            let next_out_of_line = decoder.next_out_of_line();
14115            let handles_before = decoder.remaining_handles();
14116            if let Some((inlined, num_bytes, num_handles)) =
14117                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14118            {
14119                let member_inline_size =
14120                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14121                if inlined != (member_inline_size <= 4) {
14122                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14123                }
14124                let inner_offset;
14125                let mut inner_depth = depth.clone();
14126                if inlined {
14127                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14128                    inner_offset = next_offset;
14129                } else {
14130                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14131                    inner_depth.increment()?;
14132                }
14133                let val_ref = self.thread_rloc.get_or_insert_with(|| fidl::new_empty!(u16, D));
14134                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
14135                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14136                {
14137                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14138                }
14139                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14140                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14141                }
14142            }
14143
14144            next_offset += envelope_size;
14145            _next_ordinal_to_read += 1;
14146            if next_offset >= end_offset {
14147                return Ok(());
14148            }
14149
14150            // Decode unknown envelopes for gaps in ordinals.
14151            while _next_ordinal_to_read < 10 {
14152                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14153                _next_ordinal_to_read += 1;
14154                next_offset += envelope_size;
14155            }
14156
14157            let next_out_of_line = decoder.next_out_of_line();
14158            let handles_before = decoder.remaining_handles();
14159            if let Some((inlined, num_bytes, num_handles)) =
14160                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14161            {
14162                let member_inline_size =
14163                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14164                if inlined != (member_inline_size <= 4) {
14165                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14166                }
14167                let inner_offset;
14168                let mut inner_depth = depth.clone();
14169                if inlined {
14170                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14171                    inner_offset = next_offset;
14172                } else {
14173                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14174                    inner_depth.increment()?;
14175                }
14176                let val_ref =
14177                    self.thread_network_data_version.get_or_insert_with(|| fidl::new_empty!(u8, D));
14178                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
14179                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14180                {
14181                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14182                }
14183                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14184                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14185                }
14186            }
14187
14188            next_offset += envelope_size;
14189            _next_ordinal_to_read += 1;
14190            if next_offset >= end_offset {
14191                return Ok(());
14192            }
14193
14194            // Decode unknown envelopes for gaps in ordinals.
14195            while _next_ordinal_to_read < 11 {
14196                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14197                _next_ordinal_to_read += 1;
14198                next_offset += envelope_size;
14199            }
14200
14201            let next_out_of_line = decoder.next_out_of_line();
14202            let handles_before = decoder.remaining_handles();
14203            if let Some((inlined, num_bytes, num_handles)) =
14204                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14205            {
14206                let member_inline_size =
14207                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14208                if inlined != (member_inline_size <= 4) {
14209                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14210                }
14211                let inner_offset;
14212                let mut inner_depth = depth.clone();
14213                if inlined {
14214                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14215                    inner_offset = next_offset;
14216                } else {
14217                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14218                    inner_depth.increment()?;
14219                }
14220                let val_ref = self
14221                    .thread_stable_network_data_version
14222                    .get_or_insert_with(|| fidl::new_empty!(u8, D));
14223                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
14224                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14225                {
14226                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14227                }
14228                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14229                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14230                }
14231            }
14232
14233            next_offset += envelope_size;
14234            _next_ordinal_to_read += 1;
14235            if next_offset >= end_offset {
14236                return Ok(());
14237            }
14238
14239            // Decode unknown envelopes for gaps in ordinals.
14240            while _next_ordinal_to_read < 12 {
14241                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14242                _next_ordinal_to_read += 1;
14243                next_offset += envelope_size;
14244            }
14245
14246            let next_out_of_line = decoder.next_out_of_line();
14247            let handles_before = decoder.remaining_handles();
14248            if let Some((inlined, num_bytes, num_handles)) =
14249                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14250            {
14251                let member_inline_size =
14252                    <fidl::encoding::Vector<u8, 255> as fidl::encoding::TypeMarker>::inline_size(
14253                        decoder.context,
14254                    );
14255                if inlined != (member_inline_size <= 4) {
14256                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14257                }
14258                let inner_offset;
14259                let mut inner_depth = depth.clone();
14260                if inlined {
14261                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14262                    inner_offset = next_offset;
14263                } else {
14264                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14265                    inner_depth.increment()?;
14266                }
14267                let val_ref = self
14268                    .thread_network_data
14269                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 255>, D));
14270                fidl::decode!(fidl::encoding::Vector<u8, 255>, D, val_ref, decoder, inner_offset, inner_depth)?;
14271                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14272                {
14273                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14274                }
14275                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14276                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14277                }
14278            }
14279
14280            next_offset += envelope_size;
14281            _next_ordinal_to_read += 1;
14282            if next_offset >= end_offset {
14283                return Ok(());
14284            }
14285
14286            // Decode unknown envelopes for gaps in ordinals.
14287            while _next_ordinal_to_read < 13 {
14288                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14289                _next_ordinal_to_read += 1;
14290                next_offset += envelope_size;
14291            }
14292
14293            let next_out_of_line = decoder.next_out_of_line();
14294            let handles_before = decoder.remaining_handles();
14295            if let Some((inlined, num_bytes, num_handles)) =
14296                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14297            {
14298                let member_inline_size =
14299                    <fidl::encoding::Vector<u8, 255> as fidl::encoding::TypeMarker>::inline_size(
14300                        decoder.context,
14301                    );
14302                if inlined != (member_inline_size <= 4) {
14303                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14304                }
14305                let inner_offset;
14306                let mut inner_depth = depth.clone();
14307                if inlined {
14308                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14309                    inner_offset = next_offset;
14310                } else {
14311                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14312                    inner_depth.increment()?;
14313                }
14314                let val_ref = self
14315                    .thread_stable_network_data
14316                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 255>, D));
14317                fidl::decode!(fidl::encoding::Vector<u8, 255>, D, val_ref, decoder, inner_offset, inner_depth)?;
14318                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14319                {
14320                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14321                }
14322                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14323                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14324                }
14325            }
14326
14327            next_offset += envelope_size;
14328            _next_ordinal_to_read += 1;
14329            if next_offset >= end_offset {
14330                return Ok(());
14331            }
14332
14333            // Decode unknown envelopes for gaps in ordinals.
14334            while _next_ordinal_to_read < 14 {
14335                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14336                _next_ordinal_to_read += 1;
14337                next_offset += envelope_size;
14338            }
14339
14340            let next_out_of_line = decoder.next_out_of_line();
14341            let handles_before = decoder.remaining_handles();
14342            if let Some((inlined, num_bytes, num_handles)) =
14343                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14344            {
14345                let member_inline_size =
14346                    <BorderRoutingCounters as fidl::encoding::TypeMarker>::inline_size(
14347                        decoder.context,
14348                    );
14349                if inlined != (member_inline_size <= 4) {
14350                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14351                }
14352                let inner_offset;
14353                let mut inner_depth = depth.clone();
14354                if inlined {
14355                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14356                    inner_offset = next_offset;
14357                } else {
14358                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14359                    inner_depth.increment()?;
14360                }
14361                let val_ref = self
14362                    .thread_border_routing_counters
14363                    .get_or_insert_with(|| fidl::new_empty!(BorderRoutingCounters, D));
14364                fidl::decode!(
14365                    BorderRoutingCounters,
14366                    D,
14367                    val_ref,
14368                    decoder,
14369                    inner_offset,
14370                    inner_depth
14371                )?;
14372                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14373                {
14374                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14375                }
14376                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14377                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14378                }
14379            }
14380
14381            next_offset += envelope_size;
14382            _next_ordinal_to_read += 1;
14383            if next_offset >= end_offset {
14384                return Ok(());
14385            }
14386
14387            // Decode unknown envelopes for gaps in ordinals.
14388            while _next_ordinal_to_read < 15 {
14389                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14390                _next_ordinal_to_read += 1;
14391                next_offset += envelope_size;
14392            }
14393
14394            let next_out_of_line = decoder.next_out_of_line();
14395            let handles_before = decoder.remaining_handles();
14396            if let Some((inlined, num_bytes, num_handles)) =
14397                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14398            {
14399                let member_inline_size =
14400                    <SrpServerInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14401                if inlined != (member_inline_size <= 4) {
14402                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14403                }
14404                let inner_offset;
14405                let mut inner_depth = depth.clone();
14406                if inlined {
14407                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14408                    inner_offset = next_offset;
14409                } else {
14410                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14411                    inner_depth.increment()?;
14412                }
14413                let val_ref =
14414                    self.srp_server_info.get_or_insert_with(|| fidl::new_empty!(SrpServerInfo, D));
14415                fidl::decode!(SrpServerInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
14416                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14417                {
14418                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14419                }
14420                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14421                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14422                }
14423            }
14424
14425            next_offset += envelope_size;
14426            _next_ordinal_to_read += 1;
14427            if next_offset >= end_offset {
14428                return Ok(());
14429            }
14430
14431            // Decode unknown envelopes for gaps in ordinals.
14432            while _next_ordinal_to_read < 16 {
14433                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14434                _next_ordinal_to_read += 1;
14435                next_offset += envelope_size;
14436            }
14437
14438            let next_out_of_line = decoder.next_out_of_line();
14439            let handles_before = decoder.remaining_handles();
14440            if let Some((inlined, num_bytes, num_handles)) =
14441                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14442            {
14443                let member_inline_size =
14444                    <DnssdCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14445                if inlined != (member_inline_size <= 4) {
14446                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14447                }
14448                let inner_offset;
14449                let mut inner_depth = depth.clone();
14450                if inlined {
14451                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14452                    inner_offset = next_offset;
14453                } else {
14454                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14455                    inner_depth.increment()?;
14456                }
14457                let val_ref =
14458                    self.dnssd_counters.get_or_insert_with(|| fidl::new_empty!(DnssdCounters, D));
14459                fidl::decode!(DnssdCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
14460                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14461                {
14462                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14463                }
14464                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14465                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14466                }
14467            }
14468
14469            next_offset += envelope_size;
14470            _next_ordinal_to_read += 1;
14471            if next_offset >= end_offset {
14472                return Ok(());
14473            }
14474
14475            // Decode unknown envelopes for gaps in ordinals.
14476            while _next_ordinal_to_read < 17 {
14477                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14478                _next_ordinal_to_read += 1;
14479                next_offset += envelope_size;
14480            }
14481
14482            let next_out_of_line = decoder.next_out_of_line();
14483            let handles_before = decoder.remaining_handles();
14484            if let Some((inlined, num_bytes, num_handles)) =
14485                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14486            {
14487                let member_inline_size =
14488                    <LeaderData as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14489                if inlined != (member_inline_size <= 4) {
14490                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14491                }
14492                let inner_offset;
14493                let mut inner_depth = depth.clone();
14494                if inlined {
14495                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14496                    inner_offset = next_offset;
14497                } else {
14498                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14499                    inner_depth.increment()?;
14500                }
14501                let val_ref =
14502                    self.leader_data.get_or_insert_with(|| fidl::new_empty!(LeaderData, D));
14503                fidl::decode!(LeaderData, D, val_ref, decoder, inner_offset, inner_depth)?;
14504                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14505                {
14506                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14507                }
14508                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14509                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14510                }
14511            }
14512
14513            next_offset += envelope_size;
14514            _next_ordinal_to_read += 1;
14515            if next_offset >= end_offset {
14516                return Ok(());
14517            }
14518
14519            // Decode unknown envelopes for gaps in ordinals.
14520            while _next_ordinal_to_read < 18 {
14521                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14522                _next_ordinal_to_read += 1;
14523                next_offset += envelope_size;
14524            }
14525
14526            let next_out_of_line = decoder.next_out_of_line();
14527            let handles_before = decoder.remaining_handles();
14528            if let Some((inlined, num_bytes, num_handles)) =
14529                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14530            {
14531                let member_inline_size =
14532                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14533                if inlined != (member_inline_size <= 4) {
14534                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14535                }
14536                let inner_offset;
14537                let mut inner_depth = depth.clone();
14538                if inlined {
14539                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14540                    inner_offset = next_offset;
14541                } else {
14542                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14543                    inner_depth.increment()?;
14544                }
14545                let val_ref = self.uptime.get_or_insert_with(|| fidl::new_empty!(i64, D));
14546                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
14547                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14548                {
14549                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14550                }
14551                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14552                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14553                }
14554            }
14555
14556            next_offset += envelope_size;
14557            _next_ordinal_to_read += 1;
14558            if next_offset >= end_offset {
14559                return Ok(());
14560            }
14561
14562            // Decode unknown envelopes for gaps in ordinals.
14563            while _next_ordinal_to_read < 19 {
14564                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14565                _next_ordinal_to_read += 1;
14566                next_offset += envelope_size;
14567            }
14568
14569            let next_out_of_line = decoder.next_out_of_line();
14570            let handles_before = decoder.remaining_handles();
14571            if let Some((inlined, num_bytes, num_handles)) =
14572                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14573            {
14574                let member_inline_size =
14575                    <Nat64Info as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14576                if inlined != (member_inline_size <= 4) {
14577                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14578                }
14579                let inner_offset;
14580                let mut inner_depth = depth.clone();
14581                if inlined {
14582                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14583                    inner_offset = next_offset;
14584                } else {
14585                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14586                    inner_depth.increment()?;
14587                }
14588                let val_ref = self.nat64_info.get_or_insert_with(|| fidl::new_empty!(Nat64Info, D));
14589                fidl::decode!(Nat64Info, D, val_ref, decoder, inner_offset, inner_depth)?;
14590                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14591                {
14592                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14593                }
14594                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14595                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14596                }
14597            }
14598
14599            next_offset += envelope_size;
14600            _next_ordinal_to_read += 1;
14601            if next_offset >= end_offset {
14602                return Ok(());
14603            }
14604
14605            // Decode unknown envelopes for gaps in ordinals.
14606            while _next_ordinal_to_read < 20 {
14607                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14608                _next_ordinal_to_read += 1;
14609                next_offset += envelope_size;
14610            }
14611
14612            let next_out_of_line = decoder.next_out_of_line();
14613            let handles_before = decoder.remaining_handles();
14614            if let Some((inlined, num_bytes, num_handles)) =
14615                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14616            {
14617                let member_inline_size =
14618                    <TrelCounters as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14619                if inlined != (member_inline_size <= 4) {
14620                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14621                }
14622                let inner_offset;
14623                let mut inner_depth = depth.clone();
14624                if inlined {
14625                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14626                    inner_offset = next_offset;
14627                } else {
14628                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14629                    inner_depth.increment()?;
14630                }
14631                let val_ref =
14632                    self.trel_counters.get_or_insert_with(|| fidl::new_empty!(TrelCounters, D));
14633                fidl::decode!(TrelCounters, D, val_ref, decoder, inner_offset, inner_depth)?;
14634                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14635                {
14636                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14637                }
14638                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14639                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14640                }
14641            }
14642
14643            next_offset += envelope_size;
14644            _next_ordinal_to_read += 1;
14645            if next_offset >= end_offset {
14646                return Ok(());
14647            }
14648
14649            // Decode unknown envelopes for gaps in ordinals.
14650            while _next_ordinal_to_read < 21 {
14651                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14652                _next_ordinal_to_read += 1;
14653                next_offset += envelope_size;
14654            }
14655
14656            let next_out_of_line = decoder.next_out_of_line();
14657            let handles_before = decoder.remaining_handles();
14658            if let Some((inlined, num_bytes, num_handles)) =
14659                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14660            {
14661                let member_inline_size =
14662                    <TrelPeersInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14663                if inlined != (member_inline_size <= 4) {
14664                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14665                }
14666                let inner_offset;
14667                let mut inner_depth = depth.clone();
14668                if inlined {
14669                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14670                    inner_offset = next_offset;
14671                } else {
14672                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14673                    inner_depth.increment()?;
14674                }
14675                let val_ref =
14676                    self.trel_peers_info.get_or_insert_with(|| fidl::new_empty!(TrelPeersInfo, D));
14677                fidl::decode!(TrelPeersInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
14678                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14679                {
14680                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14681                }
14682                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14683                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14684                }
14685            }
14686
14687            next_offset += envelope_size;
14688            _next_ordinal_to_read += 1;
14689            if next_offset >= end_offset {
14690                return Ok(());
14691            }
14692
14693            // Decode unknown envelopes for gaps in ordinals.
14694            while _next_ordinal_to_read < 22 {
14695                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14696                _next_ordinal_to_read += 1;
14697                next_offset += envelope_size;
14698            }
14699
14700            let next_out_of_line = decoder.next_out_of_line();
14701            let handles_before = decoder.remaining_handles();
14702            if let Some((inlined, num_bytes, num_handles)) =
14703                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14704            {
14705                let member_inline_size =
14706                    <UpstreamDnsInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14707                if inlined != (member_inline_size <= 4) {
14708                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14709                }
14710                let inner_offset;
14711                let mut inner_depth = depth.clone();
14712                if inlined {
14713                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14714                    inner_offset = next_offset;
14715                } else {
14716                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14717                    inner_depth.increment()?;
14718                }
14719                let val_ref = self
14720                    .upstream_dns_info
14721                    .get_or_insert_with(|| fidl::new_empty!(UpstreamDnsInfo, D));
14722                fidl::decode!(UpstreamDnsInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
14723                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14724                {
14725                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14726                }
14727                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14728                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14729                }
14730            }
14731
14732            next_offset += envelope_size;
14733            _next_ordinal_to_read += 1;
14734            if next_offset >= end_offset {
14735                return Ok(());
14736            }
14737
14738            // Decode unknown envelopes for gaps in ordinals.
14739            while _next_ordinal_to_read < 23 {
14740                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14741                _next_ordinal_to_read += 1;
14742                next_offset += envelope_size;
14743            }
14744
14745            let next_out_of_line = decoder.next_out_of_line();
14746            let handles_before = decoder.remaining_handles();
14747            if let Some((inlined, num_bytes, num_handles)) =
14748                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14749            {
14750                let member_inline_size =
14751                    <Dhcp6PdInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14752                if inlined != (member_inline_size <= 4) {
14753                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14754                }
14755                let inner_offset;
14756                let mut inner_depth = depth.clone();
14757                if inlined {
14758                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14759                    inner_offset = next_offset;
14760                } else {
14761                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14762                    inner_depth.increment()?;
14763                }
14764                let val_ref =
14765                    self.dhcp6pd_info.get_or_insert_with(|| fidl::new_empty!(Dhcp6PdInfo, D));
14766                fidl::decode!(Dhcp6PdInfo, D, val_ref, decoder, inner_offset, inner_depth)?;
14767                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14768                {
14769                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14770                }
14771                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14772                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14773                }
14774            }
14775
14776            next_offset += envelope_size;
14777            _next_ordinal_to_read += 1;
14778            if next_offset >= end_offset {
14779                return Ok(());
14780            }
14781
14782            // Decode unknown envelopes for gaps in ordinals.
14783            while _next_ordinal_to_read < 24 {
14784                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14785                _next_ordinal_to_read += 1;
14786                next_offset += envelope_size;
14787            }
14788
14789            let next_out_of_line = decoder.next_out_of_line();
14790            let handles_before = decoder.remaining_handles();
14791            if let Some((inlined, num_bytes, num_handles)) =
14792                fidl::encoding::decode_envelope_header(decoder, next_offset)?
14793            {
14794                let member_inline_size = <fidl::encoding::Vector<LinkMetricsEntry, 64> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
14795                if inlined != (member_inline_size <= 4) {
14796                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
14797                }
14798                let inner_offset;
14799                let mut inner_depth = depth.clone();
14800                if inlined {
14801                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
14802                    inner_offset = next_offset;
14803                } else {
14804                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
14805                    inner_depth.increment()?;
14806                }
14807                let val_ref = self.link_metrics_entries.get_or_insert_with(
14808                    || fidl::new_empty!(fidl::encoding::Vector<LinkMetricsEntry, 64>, D),
14809                );
14810                fidl::decode!(fidl::encoding::Vector<LinkMetricsEntry, 64>, D, val_ref, decoder, inner_offset, inner_depth)?;
14811                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
14812                {
14813                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
14814                }
14815                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
14816                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
14817                }
14818            }
14819
14820            next_offset += envelope_size;
14821
14822            // Decode the remaining unknown envelopes.
14823            while next_offset < end_offset {
14824                _next_ordinal_to_read += 1;
14825                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
14826                next_offset += envelope_size;
14827            }
14828
14829            Ok(())
14830        }
14831    }
14832
14833    impl TrelCounters {
14834        #[inline(always)]
14835        fn max_ordinal_present(&self) -> u64 {
14836            if let Some(_) = self.tx_packets {
14837                return 5;
14838            }
14839            if let Some(_) = self.tx_failure {
14840                return 4;
14841            }
14842            if let Some(_) = self.tx_bytes {
14843                return 3;
14844            }
14845            if let Some(_) = self.rx_packets {
14846                return 2;
14847            }
14848            if let Some(_) = self.rx_bytes {
14849                return 1;
14850            }
14851            0
14852        }
14853    }
14854
14855    impl fidl::encoding::ValueTypeMarker for TrelCounters {
14856        type Borrowed<'a> = &'a Self;
14857        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
14858            value
14859        }
14860    }
14861
14862    unsafe impl fidl::encoding::TypeMarker for TrelCounters {
14863        type Owned = Self;
14864
14865        #[inline(always)]
14866        fn inline_align(_context: fidl::encoding::Context) -> usize {
14867            8
14868        }
14869
14870        #[inline(always)]
14871        fn inline_size(_context: fidl::encoding::Context) -> usize {
14872            16
14873        }
14874    }
14875
14876    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TrelCounters, D>
14877        for &TrelCounters
14878    {
14879        unsafe fn encode(
14880            self,
14881            encoder: &mut fidl::encoding::Encoder<'_, D>,
14882            offset: usize,
14883            mut depth: fidl::encoding::Depth,
14884        ) -> fidl::Result<()> {
14885            encoder.debug_check_bounds::<TrelCounters>(offset);
14886            // Vector header
14887            let max_ordinal: u64 = self.max_ordinal_present();
14888            encoder.write_num(max_ordinal, offset);
14889            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14890            // Calling encoder.out_of_line_offset(0) is not allowed.
14891            if max_ordinal == 0 {
14892                return Ok(());
14893            }
14894            depth.increment()?;
14895            let envelope_size = 8;
14896            let bytes_len = max_ordinal as usize * envelope_size;
14897            #[allow(unused_variables)]
14898            let offset = encoder.out_of_line_offset(bytes_len);
14899            let mut _prev_end_offset: usize = 0;
14900            if 1 > max_ordinal {
14901                return Ok(());
14902            }
14903
14904            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14905            // are envelope_size bytes.
14906            let cur_offset: usize = (1 - 1) * envelope_size;
14907
14908            // Zero reserved fields.
14909            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14910
14911            // Safety:
14912            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14913            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14914            //   envelope_size bytes, there is always sufficient room.
14915            fidl::encoding::encode_in_envelope_optional::<u64, D>(
14916                self.rx_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14917                encoder,
14918                offset + cur_offset,
14919                depth,
14920            )?;
14921
14922            _prev_end_offset = cur_offset + envelope_size;
14923            if 2 > max_ordinal {
14924                return Ok(());
14925            }
14926
14927            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14928            // are envelope_size bytes.
14929            let cur_offset: usize = (2 - 1) * envelope_size;
14930
14931            // Zero reserved fields.
14932            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14933
14934            // Safety:
14935            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14936            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14937            //   envelope_size bytes, there is always sufficient room.
14938            fidl::encoding::encode_in_envelope_optional::<u64, D>(
14939                self.rx_packets.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14940                encoder,
14941                offset + cur_offset,
14942                depth,
14943            )?;
14944
14945            _prev_end_offset = cur_offset + envelope_size;
14946            if 3 > max_ordinal {
14947                return Ok(());
14948            }
14949
14950            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14951            // are envelope_size bytes.
14952            let cur_offset: usize = (3 - 1) * envelope_size;
14953
14954            // Zero reserved fields.
14955            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14956
14957            // Safety:
14958            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14959            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14960            //   envelope_size bytes, there is always sufficient room.
14961            fidl::encoding::encode_in_envelope_optional::<u64, D>(
14962                self.tx_bytes.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14963                encoder,
14964                offset + cur_offset,
14965                depth,
14966            )?;
14967
14968            _prev_end_offset = cur_offset + envelope_size;
14969            if 4 > max_ordinal {
14970                return Ok(());
14971            }
14972
14973            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14974            // are envelope_size bytes.
14975            let cur_offset: usize = (4 - 1) * envelope_size;
14976
14977            // Zero reserved fields.
14978            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14979
14980            // Safety:
14981            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14982            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14983            //   envelope_size bytes, there is always sufficient room.
14984            fidl::encoding::encode_in_envelope_optional::<u64, D>(
14985                self.tx_failure.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14986                encoder,
14987                offset + cur_offset,
14988                depth,
14989            )?;
14990
14991            _prev_end_offset = cur_offset + envelope_size;
14992            if 5 > max_ordinal {
14993                return Ok(());
14994            }
14995
14996            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14997            // are envelope_size bytes.
14998            let cur_offset: usize = (5 - 1) * envelope_size;
14999
15000            // Zero reserved fields.
15001            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15002
15003            // Safety:
15004            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15005            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15006            //   envelope_size bytes, there is always sufficient room.
15007            fidl::encoding::encode_in_envelope_optional::<u64, D>(
15008                self.tx_packets.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
15009                encoder,
15010                offset + cur_offset,
15011                depth,
15012            )?;
15013
15014            _prev_end_offset = cur_offset + envelope_size;
15015
15016            Ok(())
15017        }
15018    }
15019
15020    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TrelCounters {
15021        #[inline(always)]
15022        fn new_empty() -> Self {
15023            Self::default()
15024        }
15025
15026        unsafe fn decode(
15027            &mut self,
15028            decoder: &mut fidl::encoding::Decoder<'_, D>,
15029            offset: usize,
15030            mut depth: fidl::encoding::Depth,
15031        ) -> fidl::Result<()> {
15032            decoder.debug_check_bounds::<Self>(offset);
15033            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15034                None => return Err(fidl::Error::NotNullable),
15035                Some(len) => len,
15036            };
15037            // Calling decoder.out_of_line_offset(0) is not allowed.
15038            if len == 0 {
15039                return Ok(());
15040            };
15041            depth.increment()?;
15042            let envelope_size = 8;
15043            let bytes_len = len * envelope_size;
15044            let offset = decoder.out_of_line_offset(bytes_len)?;
15045            // Decode the envelope for each type.
15046            let mut _next_ordinal_to_read = 0;
15047            let mut next_offset = offset;
15048            let end_offset = offset + bytes_len;
15049            _next_ordinal_to_read += 1;
15050            if next_offset >= end_offset {
15051                return Ok(());
15052            }
15053
15054            // Decode unknown envelopes for gaps in ordinals.
15055            while _next_ordinal_to_read < 1 {
15056                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15057                _next_ordinal_to_read += 1;
15058                next_offset += envelope_size;
15059            }
15060
15061            let next_out_of_line = decoder.next_out_of_line();
15062            let handles_before = decoder.remaining_handles();
15063            if let Some((inlined, num_bytes, num_handles)) =
15064                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15065            {
15066                let member_inline_size =
15067                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15068                if inlined != (member_inline_size <= 4) {
15069                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15070                }
15071                let inner_offset;
15072                let mut inner_depth = depth.clone();
15073                if inlined {
15074                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15075                    inner_offset = next_offset;
15076                } else {
15077                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15078                    inner_depth.increment()?;
15079                }
15080                let val_ref = self.rx_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
15081                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15082                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15083                {
15084                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15085                }
15086                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15087                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15088                }
15089            }
15090
15091            next_offset += envelope_size;
15092            _next_ordinal_to_read += 1;
15093            if next_offset >= end_offset {
15094                return Ok(());
15095            }
15096
15097            // Decode unknown envelopes for gaps in ordinals.
15098            while _next_ordinal_to_read < 2 {
15099                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15100                _next_ordinal_to_read += 1;
15101                next_offset += envelope_size;
15102            }
15103
15104            let next_out_of_line = decoder.next_out_of_line();
15105            let handles_before = decoder.remaining_handles();
15106            if let Some((inlined, num_bytes, num_handles)) =
15107                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15108            {
15109                let member_inline_size =
15110                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15111                if inlined != (member_inline_size <= 4) {
15112                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15113                }
15114                let inner_offset;
15115                let mut inner_depth = depth.clone();
15116                if inlined {
15117                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15118                    inner_offset = next_offset;
15119                } else {
15120                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15121                    inner_depth.increment()?;
15122                }
15123                let val_ref = self.rx_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
15124                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15125                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15126                {
15127                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15128                }
15129                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15130                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15131                }
15132            }
15133
15134            next_offset += envelope_size;
15135            _next_ordinal_to_read += 1;
15136            if next_offset >= end_offset {
15137                return Ok(());
15138            }
15139
15140            // Decode unknown envelopes for gaps in ordinals.
15141            while _next_ordinal_to_read < 3 {
15142                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15143                _next_ordinal_to_read += 1;
15144                next_offset += envelope_size;
15145            }
15146
15147            let next_out_of_line = decoder.next_out_of_line();
15148            let handles_before = decoder.remaining_handles();
15149            if let Some((inlined, num_bytes, num_handles)) =
15150                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15151            {
15152                let member_inline_size =
15153                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15154                if inlined != (member_inline_size <= 4) {
15155                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15156                }
15157                let inner_offset;
15158                let mut inner_depth = depth.clone();
15159                if inlined {
15160                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15161                    inner_offset = next_offset;
15162                } else {
15163                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15164                    inner_depth.increment()?;
15165                }
15166                let val_ref = self.tx_bytes.get_or_insert_with(|| fidl::new_empty!(u64, D));
15167                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15168                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15169                {
15170                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15171                }
15172                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15173                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15174                }
15175            }
15176
15177            next_offset += envelope_size;
15178            _next_ordinal_to_read += 1;
15179            if next_offset >= end_offset {
15180                return Ok(());
15181            }
15182
15183            // Decode unknown envelopes for gaps in ordinals.
15184            while _next_ordinal_to_read < 4 {
15185                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15186                _next_ordinal_to_read += 1;
15187                next_offset += envelope_size;
15188            }
15189
15190            let next_out_of_line = decoder.next_out_of_line();
15191            let handles_before = decoder.remaining_handles();
15192            if let Some((inlined, num_bytes, num_handles)) =
15193                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15194            {
15195                let member_inline_size =
15196                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15197                if inlined != (member_inline_size <= 4) {
15198                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15199                }
15200                let inner_offset;
15201                let mut inner_depth = depth.clone();
15202                if inlined {
15203                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15204                    inner_offset = next_offset;
15205                } else {
15206                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15207                    inner_depth.increment()?;
15208                }
15209                let val_ref = self.tx_failure.get_or_insert_with(|| fidl::new_empty!(u64, D));
15210                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15211                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15212                {
15213                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15214                }
15215                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15216                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15217                }
15218            }
15219
15220            next_offset += envelope_size;
15221            _next_ordinal_to_read += 1;
15222            if next_offset >= end_offset {
15223                return Ok(());
15224            }
15225
15226            // Decode unknown envelopes for gaps in ordinals.
15227            while _next_ordinal_to_read < 5 {
15228                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15229                _next_ordinal_to_read += 1;
15230                next_offset += envelope_size;
15231            }
15232
15233            let next_out_of_line = decoder.next_out_of_line();
15234            let handles_before = decoder.remaining_handles();
15235            if let Some((inlined, num_bytes, num_handles)) =
15236                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15237            {
15238                let member_inline_size =
15239                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15240                if inlined != (member_inline_size <= 4) {
15241                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15242                }
15243                let inner_offset;
15244                let mut inner_depth = depth.clone();
15245                if inlined {
15246                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15247                    inner_offset = next_offset;
15248                } else {
15249                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15250                    inner_depth.increment()?;
15251                }
15252                let val_ref = self.tx_packets.get_or_insert_with(|| fidl::new_empty!(u64, D));
15253                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
15254                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15255                {
15256                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15257                }
15258                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15259                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15260                }
15261            }
15262
15263            next_offset += envelope_size;
15264
15265            // Decode the remaining unknown envelopes.
15266            while next_offset < end_offset {
15267                _next_ordinal_to_read += 1;
15268                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15269                next_offset += envelope_size;
15270            }
15271
15272            Ok(())
15273        }
15274    }
15275
15276    impl TrelPeersInfo {
15277        #[inline(always)]
15278        fn max_ordinal_present(&self) -> u64 {
15279            if let Some(_) = self.num_trel_peers {
15280                return 1;
15281            }
15282            0
15283        }
15284    }
15285
15286    impl fidl::encoding::ValueTypeMarker for TrelPeersInfo {
15287        type Borrowed<'a> = &'a Self;
15288        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15289            value
15290        }
15291    }
15292
15293    unsafe impl fidl::encoding::TypeMarker for TrelPeersInfo {
15294        type Owned = Self;
15295
15296        #[inline(always)]
15297        fn inline_align(_context: fidl::encoding::Context) -> usize {
15298            8
15299        }
15300
15301        #[inline(always)]
15302        fn inline_size(_context: fidl::encoding::Context) -> usize {
15303            16
15304        }
15305    }
15306
15307    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<TrelPeersInfo, D>
15308        for &TrelPeersInfo
15309    {
15310        unsafe fn encode(
15311            self,
15312            encoder: &mut fidl::encoding::Encoder<'_, D>,
15313            offset: usize,
15314            mut depth: fidl::encoding::Depth,
15315        ) -> fidl::Result<()> {
15316            encoder.debug_check_bounds::<TrelPeersInfo>(offset);
15317            // Vector header
15318            let max_ordinal: u64 = self.max_ordinal_present();
15319            encoder.write_num(max_ordinal, offset);
15320            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15321            // Calling encoder.out_of_line_offset(0) is not allowed.
15322            if max_ordinal == 0 {
15323                return Ok(());
15324            }
15325            depth.increment()?;
15326            let envelope_size = 8;
15327            let bytes_len = max_ordinal as usize * envelope_size;
15328            #[allow(unused_variables)]
15329            let offset = encoder.out_of_line_offset(bytes_len);
15330            let mut _prev_end_offset: usize = 0;
15331            if 1 > max_ordinal {
15332                return Ok(());
15333            }
15334
15335            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15336            // are envelope_size bytes.
15337            let cur_offset: usize = (1 - 1) * envelope_size;
15338
15339            // Zero reserved fields.
15340            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15341
15342            // Safety:
15343            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15344            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15345            //   envelope_size bytes, there is always sufficient room.
15346            fidl::encoding::encode_in_envelope_optional::<u16, D>(
15347                self.num_trel_peers.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
15348                encoder,
15349                offset + cur_offset,
15350                depth,
15351            )?;
15352
15353            _prev_end_offset = cur_offset + envelope_size;
15354
15355            Ok(())
15356        }
15357    }
15358
15359    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for TrelPeersInfo {
15360        #[inline(always)]
15361        fn new_empty() -> Self {
15362            Self::default()
15363        }
15364
15365        unsafe fn decode(
15366            &mut self,
15367            decoder: &mut fidl::encoding::Decoder<'_, D>,
15368            offset: usize,
15369            mut depth: fidl::encoding::Depth,
15370        ) -> fidl::Result<()> {
15371            decoder.debug_check_bounds::<Self>(offset);
15372            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15373                None => return Err(fidl::Error::NotNullable),
15374                Some(len) => len,
15375            };
15376            // Calling decoder.out_of_line_offset(0) is not allowed.
15377            if len == 0 {
15378                return Ok(());
15379            };
15380            depth.increment()?;
15381            let envelope_size = 8;
15382            let bytes_len = len * envelope_size;
15383            let offset = decoder.out_of_line_offset(bytes_len)?;
15384            // Decode the envelope for each type.
15385            let mut _next_ordinal_to_read = 0;
15386            let mut next_offset = offset;
15387            let end_offset = offset + bytes_len;
15388            _next_ordinal_to_read += 1;
15389            if next_offset >= end_offset {
15390                return Ok(());
15391            }
15392
15393            // Decode unknown envelopes for gaps in ordinals.
15394            while _next_ordinal_to_read < 1 {
15395                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15396                _next_ordinal_to_read += 1;
15397                next_offset += envelope_size;
15398            }
15399
15400            let next_out_of_line = decoder.next_out_of_line();
15401            let handles_before = decoder.remaining_handles();
15402            if let Some((inlined, num_bytes, num_handles)) =
15403                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15404            {
15405                let member_inline_size =
15406                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15407                if inlined != (member_inline_size <= 4) {
15408                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15409                }
15410                let inner_offset;
15411                let mut inner_depth = depth.clone();
15412                if inlined {
15413                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15414                    inner_offset = next_offset;
15415                } else {
15416                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15417                    inner_depth.increment()?;
15418                }
15419                let val_ref = self.num_trel_peers.get_or_insert_with(|| fidl::new_empty!(u16, D));
15420                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
15421                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15422                {
15423                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15424                }
15425                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15426                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15427                }
15428            }
15429
15430            next_offset += envelope_size;
15431
15432            // Decode the remaining unknown envelopes.
15433            while next_offset < end_offset {
15434                _next_ordinal_to_read += 1;
15435                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15436                next_offset += envelope_size;
15437            }
15438
15439            Ok(())
15440        }
15441    }
15442
15443    impl UpstreamDnsCounters {
15444        #[inline(always)]
15445        fn max_ordinal_present(&self) -> u64 {
15446            if let Some(_) = self.failures {
15447                return 3;
15448            }
15449            if let Some(_) = self.responses {
15450                return 2;
15451            }
15452            if let Some(_) = self.queries {
15453                return 1;
15454            }
15455            0
15456        }
15457    }
15458
15459    impl fidl::encoding::ValueTypeMarker for UpstreamDnsCounters {
15460        type Borrowed<'a> = &'a Self;
15461        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15462            value
15463        }
15464    }
15465
15466    unsafe impl fidl::encoding::TypeMarker for UpstreamDnsCounters {
15467        type Owned = Self;
15468
15469        #[inline(always)]
15470        fn inline_align(_context: fidl::encoding::Context) -> usize {
15471            8
15472        }
15473
15474        #[inline(always)]
15475        fn inline_size(_context: fidl::encoding::Context) -> usize {
15476            16
15477        }
15478    }
15479
15480    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UpstreamDnsCounters, D>
15481        for &UpstreamDnsCounters
15482    {
15483        unsafe fn encode(
15484            self,
15485            encoder: &mut fidl::encoding::Encoder<'_, D>,
15486            offset: usize,
15487            mut depth: fidl::encoding::Depth,
15488        ) -> fidl::Result<()> {
15489            encoder.debug_check_bounds::<UpstreamDnsCounters>(offset);
15490            // Vector header
15491            let max_ordinal: u64 = self.max_ordinal_present();
15492            encoder.write_num(max_ordinal, offset);
15493            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15494            // Calling encoder.out_of_line_offset(0) is not allowed.
15495            if max_ordinal == 0 {
15496                return Ok(());
15497            }
15498            depth.increment()?;
15499            let envelope_size = 8;
15500            let bytes_len = max_ordinal as usize * envelope_size;
15501            #[allow(unused_variables)]
15502            let offset = encoder.out_of_line_offset(bytes_len);
15503            let mut _prev_end_offset: usize = 0;
15504            if 1 > max_ordinal {
15505                return Ok(());
15506            }
15507
15508            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15509            // are envelope_size bytes.
15510            let cur_offset: usize = (1 - 1) * envelope_size;
15511
15512            // Zero reserved fields.
15513            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15514
15515            // Safety:
15516            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15517            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15518            //   envelope_size bytes, there is always sufficient room.
15519            fidl::encoding::encode_in_envelope_optional::<u32, D>(
15520                self.queries.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
15521                encoder,
15522                offset + cur_offset,
15523                depth,
15524            )?;
15525
15526            _prev_end_offset = cur_offset + envelope_size;
15527            if 2 > max_ordinal {
15528                return Ok(());
15529            }
15530
15531            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15532            // are envelope_size bytes.
15533            let cur_offset: usize = (2 - 1) * envelope_size;
15534
15535            // Zero reserved fields.
15536            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15537
15538            // Safety:
15539            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15540            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15541            //   envelope_size bytes, there is always sufficient room.
15542            fidl::encoding::encode_in_envelope_optional::<u32, D>(
15543                self.responses.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
15544                encoder,
15545                offset + cur_offset,
15546                depth,
15547            )?;
15548
15549            _prev_end_offset = cur_offset + envelope_size;
15550            if 3 > max_ordinal {
15551                return Ok(());
15552            }
15553
15554            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15555            // are envelope_size bytes.
15556            let cur_offset: usize = (3 - 1) * envelope_size;
15557
15558            // Zero reserved fields.
15559            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15560
15561            // Safety:
15562            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15563            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15564            //   envelope_size bytes, there is always sufficient room.
15565            fidl::encoding::encode_in_envelope_optional::<u32, D>(
15566                self.failures.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
15567                encoder,
15568                offset + cur_offset,
15569                depth,
15570            )?;
15571
15572            _prev_end_offset = cur_offset + envelope_size;
15573
15574            Ok(())
15575        }
15576    }
15577
15578    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UpstreamDnsCounters {
15579        #[inline(always)]
15580        fn new_empty() -> Self {
15581            Self::default()
15582        }
15583
15584        unsafe fn decode(
15585            &mut self,
15586            decoder: &mut fidl::encoding::Decoder<'_, D>,
15587            offset: usize,
15588            mut depth: fidl::encoding::Depth,
15589        ) -> fidl::Result<()> {
15590            decoder.debug_check_bounds::<Self>(offset);
15591            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15592                None => return Err(fidl::Error::NotNullable),
15593                Some(len) => len,
15594            };
15595            // Calling decoder.out_of_line_offset(0) is not allowed.
15596            if len == 0 {
15597                return Ok(());
15598            };
15599            depth.increment()?;
15600            let envelope_size = 8;
15601            let bytes_len = len * envelope_size;
15602            let offset = decoder.out_of_line_offset(bytes_len)?;
15603            // Decode the envelope for each type.
15604            let mut _next_ordinal_to_read = 0;
15605            let mut next_offset = offset;
15606            let end_offset = offset + bytes_len;
15607            _next_ordinal_to_read += 1;
15608            if next_offset >= end_offset {
15609                return Ok(());
15610            }
15611
15612            // Decode unknown envelopes for gaps in ordinals.
15613            while _next_ordinal_to_read < 1 {
15614                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15615                _next_ordinal_to_read += 1;
15616                next_offset += envelope_size;
15617            }
15618
15619            let next_out_of_line = decoder.next_out_of_line();
15620            let handles_before = decoder.remaining_handles();
15621            if let Some((inlined, num_bytes, num_handles)) =
15622                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15623            {
15624                let member_inline_size =
15625                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15626                if inlined != (member_inline_size <= 4) {
15627                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15628                }
15629                let inner_offset;
15630                let mut inner_depth = depth.clone();
15631                if inlined {
15632                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15633                    inner_offset = next_offset;
15634                } else {
15635                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15636                    inner_depth.increment()?;
15637                }
15638                let val_ref = self.queries.get_or_insert_with(|| fidl::new_empty!(u32, D));
15639                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
15640                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15641                {
15642                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15643                }
15644                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15645                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15646                }
15647            }
15648
15649            next_offset += envelope_size;
15650            _next_ordinal_to_read += 1;
15651            if next_offset >= end_offset {
15652                return Ok(());
15653            }
15654
15655            // Decode unknown envelopes for gaps in ordinals.
15656            while _next_ordinal_to_read < 2 {
15657                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15658                _next_ordinal_to_read += 1;
15659                next_offset += envelope_size;
15660            }
15661
15662            let next_out_of_line = decoder.next_out_of_line();
15663            let handles_before = decoder.remaining_handles();
15664            if let Some((inlined, num_bytes, num_handles)) =
15665                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15666            {
15667                let member_inline_size =
15668                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15669                if inlined != (member_inline_size <= 4) {
15670                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15671                }
15672                let inner_offset;
15673                let mut inner_depth = depth.clone();
15674                if inlined {
15675                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15676                    inner_offset = next_offset;
15677                } else {
15678                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15679                    inner_depth.increment()?;
15680                }
15681                let val_ref = self.responses.get_or_insert_with(|| fidl::new_empty!(u32, D));
15682                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
15683                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15684                {
15685                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15686                }
15687                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15688                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15689                }
15690            }
15691
15692            next_offset += envelope_size;
15693            _next_ordinal_to_read += 1;
15694            if next_offset >= end_offset {
15695                return Ok(());
15696            }
15697
15698            // Decode unknown envelopes for gaps in ordinals.
15699            while _next_ordinal_to_read < 3 {
15700                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15701                _next_ordinal_to_read += 1;
15702                next_offset += envelope_size;
15703            }
15704
15705            let next_out_of_line = decoder.next_out_of_line();
15706            let handles_before = decoder.remaining_handles();
15707            if let Some((inlined, num_bytes, num_handles)) =
15708                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15709            {
15710                let member_inline_size =
15711                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15712                if inlined != (member_inline_size <= 4) {
15713                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15714                }
15715                let inner_offset;
15716                let mut inner_depth = depth.clone();
15717                if inlined {
15718                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15719                    inner_offset = next_offset;
15720                } else {
15721                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15722                    inner_depth.increment()?;
15723                }
15724                let val_ref = self.failures.get_or_insert_with(|| fidl::new_empty!(u32, D));
15725                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
15726                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15727                {
15728                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15729                }
15730                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15731                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15732                }
15733            }
15734
15735            next_offset += envelope_size;
15736
15737            // Decode the remaining unknown envelopes.
15738            while next_offset < end_offset {
15739                _next_ordinal_to_read += 1;
15740                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15741                next_offset += envelope_size;
15742            }
15743
15744            Ok(())
15745        }
15746    }
15747
15748    impl UpstreamDnsInfo {
15749        #[inline(always)]
15750        fn max_ordinal_present(&self) -> u64 {
15751            if let Some(_) = self.upstream_dns_query_state {
15752                return 1;
15753            }
15754            0
15755        }
15756    }
15757
15758    impl fidl::encoding::ValueTypeMarker for UpstreamDnsInfo {
15759        type Borrowed<'a> = &'a Self;
15760        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15761            value
15762        }
15763    }
15764
15765    unsafe impl fidl::encoding::TypeMarker for UpstreamDnsInfo {
15766        type Owned = Self;
15767
15768        #[inline(always)]
15769        fn inline_align(_context: fidl::encoding::Context) -> usize {
15770            8
15771        }
15772
15773        #[inline(always)]
15774        fn inline_size(_context: fidl::encoding::Context) -> usize {
15775            16
15776        }
15777    }
15778
15779    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UpstreamDnsInfo, D>
15780        for &UpstreamDnsInfo
15781    {
15782        unsafe fn encode(
15783            self,
15784            encoder: &mut fidl::encoding::Encoder<'_, D>,
15785            offset: usize,
15786            mut depth: fidl::encoding::Depth,
15787        ) -> fidl::Result<()> {
15788            encoder.debug_check_bounds::<UpstreamDnsInfo>(offset);
15789            // Vector header
15790            let max_ordinal: u64 = self.max_ordinal_present();
15791            encoder.write_num(max_ordinal, offset);
15792            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
15793            // Calling encoder.out_of_line_offset(0) is not allowed.
15794            if max_ordinal == 0 {
15795                return Ok(());
15796            }
15797            depth.increment()?;
15798            let envelope_size = 8;
15799            let bytes_len = max_ordinal as usize * envelope_size;
15800            #[allow(unused_variables)]
15801            let offset = encoder.out_of_line_offset(bytes_len);
15802            let mut _prev_end_offset: usize = 0;
15803            if 1 > max_ordinal {
15804                return Ok(());
15805            }
15806
15807            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
15808            // are envelope_size bytes.
15809            let cur_offset: usize = (1 - 1) * envelope_size;
15810
15811            // Zero reserved fields.
15812            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
15813
15814            // Safety:
15815            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
15816            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
15817            //   envelope_size bytes, there is always sufficient room.
15818            fidl::encoding::encode_in_envelope_optional::<UpstreamDnsQueryState, D>(
15819                self.upstream_dns_query_state
15820                    .as_ref()
15821                    .map(<UpstreamDnsQueryState as fidl::encoding::ValueTypeMarker>::borrow),
15822                encoder,
15823                offset + cur_offset,
15824                depth,
15825            )?;
15826
15827            _prev_end_offset = cur_offset + envelope_size;
15828
15829            Ok(())
15830        }
15831    }
15832
15833    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UpstreamDnsInfo {
15834        #[inline(always)]
15835        fn new_empty() -> Self {
15836            Self::default()
15837        }
15838
15839        unsafe fn decode(
15840            &mut self,
15841            decoder: &mut fidl::encoding::Decoder<'_, D>,
15842            offset: usize,
15843            mut depth: fidl::encoding::Depth,
15844        ) -> fidl::Result<()> {
15845            decoder.debug_check_bounds::<Self>(offset);
15846            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15847                None => return Err(fidl::Error::NotNullable),
15848                Some(len) => len,
15849            };
15850            // Calling decoder.out_of_line_offset(0) is not allowed.
15851            if len == 0 {
15852                return Ok(());
15853            };
15854            depth.increment()?;
15855            let envelope_size = 8;
15856            let bytes_len = len * envelope_size;
15857            let offset = decoder.out_of_line_offset(bytes_len)?;
15858            // Decode the envelope for each type.
15859            let mut _next_ordinal_to_read = 0;
15860            let mut next_offset = offset;
15861            let end_offset = offset + bytes_len;
15862            _next_ordinal_to_read += 1;
15863            if next_offset >= end_offset {
15864                return Ok(());
15865            }
15866
15867            // Decode unknown envelopes for gaps in ordinals.
15868            while _next_ordinal_to_read < 1 {
15869                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15870                _next_ordinal_to_read += 1;
15871                next_offset += envelope_size;
15872            }
15873
15874            let next_out_of_line = decoder.next_out_of_line();
15875            let handles_before = decoder.remaining_handles();
15876            if let Some((inlined, num_bytes, num_handles)) =
15877                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15878            {
15879                let member_inline_size =
15880                    <UpstreamDnsQueryState as fidl::encoding::TypeMarker>::inline_size(
15881                        decoder.context,
15882                    );
15883                if inlined != (member_inline_size <= 4) {
15884                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15885                }
15886                let inner_offset;
15887                let mut inner_depth = depth.clone();
15888                if inlined {
15889                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15890                    inner_offset = next_offset;
15891                } else {
15892                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15893                    inner_depth.increment()?;
15894                }
15895                let val_ref = self
15896                    .upstream_dns_query_state
15897                    .get_or_insert_with(|| fidl::new_empty!(UpstreamDnsQueryState, D));
15898                fidl::decode!(
15899                    UpstreamDnsQueryState,
15900                    D,
15901                    val_ref,
15902                    decoder,
15903                    inner_offset,
15904                    inner_depth
15905                )?;
15906                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15907                {
15908                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15909                }
15910                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15911                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15912                }
15913            }
15914
15915            next_offset += envelope_size;
15916
15917            // Decode the remaining unknown envelopes.
15918            while next_offset < end_offset {
15919                _next_ordinal_to_read += 1;
15920                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15921                next_offset += envelope_size;
15922            }
15923
15924            Ok(())
15925        }
15926    }
15927
15928    impl fidl::encoding::ValueTypeMarker for JoinParams {
15929        type Borrowed<'a> = &'a Self;
15930        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
15931            value
15932        }
15933    }
15934
15935    unsafe impl fidl::encoding::TypeMarker for JoinParams {
15936        type Owned = Self;
15937
15938        #[inline(always)]
15939        fn inline_align(_context: fidl::encoding::Context) -> usize {
15940            8
15941        }
15942
15943        #[inline(always)]
15944        fn inline_size(_context: fidl::encoding::Context) -> usize {
15945            16
15946        }
15947    }
15948
15949    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<JoinParams, D>
15950        for &JoinParams
15951    {
15952        #[inline]
15953        unsafe fn encode(
15954            self,
15955            encoder: &mut fidl::encoding::Encoder<'_, D>,
15956            offset: usize,
15957            _depth: fidl::encoding::Depth,
15958        ) -> fidl::Result<()> {
15959            encoder.debug_check_bounds::<JoinParams>(offset);
15960            encoder.write_num::<u64>(self.ordinal(), offset);
15961            match self {
15962            JoinParams::ProvisioningParameter(ref val) => {
15963                fidl::encoding::encode_in_envelope::<fidl_fuchsia_lowpan_device__common::ProvisioningParams, D>(
15964                    <fidl_fuchsia_lowpan_device__common::ProvisioningParams as fidl::encoding::ValueTypeMarker>::borrow(val),
15965                    encoder, offset + 8, _depth
15966                )
15967            }
15968            JoinParams::JoinerParameter(ref val) => {
15969                fidl::encoding::encode_in_envelope::<JoinerCommissioningParams, D>(
15970                    <JoinerCommissioningParams as fidl::encoding::ValueTypeMarker>::borrow(val),
15971                    encoder, offset + 8, _depth
15972                )
15973            }
15974            JoinParams::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
15975        }
15976        }
15977    }
15978
15979    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for JoinParams {
15980        #[inline(always)]
15981        fn new_empty() -> Self {
15982            Self::__SourceBreaking { unknown_ordinal: 0 }
15983        }
15984
15985        #[inline]
15986        unsafe fn decode(
15987            &mut self,
15988            decoder: &mut fidl::encoding::Decoder<'_, D>,
15989            offset: usize,
15990            mut depth: fidl::encoding::Depth,
15991        ) -> fidl::Result<()> {
15992            decoder.debug_check_bounds::<Self>(offset);
15993            #[allow(unused_variables)]
15994            let next_out_of_line = decoder.next_out_of_line();
15995            let handles_before = decoder.remaining_handles();
15996            let (ordinal, inlined, num_bytes, num_handles) =
15997                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
15998
15999            let member_inline_size = match ordinal {
16000            1 => <fidl_fuchsia_lowpan_device__common::ProvisioningParams as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16001            2 => <JoinerCommissioningParams as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16002            0 => return Err(fidl::Error::UnknownUnionTag),
16003            _ => num_bytes as usize,
16004        };
16005
16006            if inlined != (member_inline_size <= 4) {
16007                return Err(fidl::Error::InvalidInlineBitInEnvelope);
16008            }
16009            let _inner_offset;
16010            if inlined {
16011                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
16012                _inner_offset = offset + 8;
16013            } else {
16014                depth.increment()?;
16015                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16016            }
16017            match ordinal {
16018                1 => {
16019                    #[allow(irrefutable_let_patterns)]
16020                    if let JoinParams::ProvisioningParameter(_) = self {
16021                        // Do nothing, read the value into the object
16022                    } else {
16023                        // Initialize `self` to the right variant
16024                        *self = JoinParams::ProvisioningParameter(fidl::new_empty!(
16025                            fidl_fuchsia_lowpan_device__common::ProvisioningParams,
16026                            D
16027                        ));
16028                    }
16029                    #[allow(irrefutable_let_patterns)]
16030                    if let JoinParams::ProvisioningParameter(ref mut val) = self {
16031                        fidl::decode!(
16032                            fidl_fuchsia_lowpan_device__common::ProvisioningParams,
16033                            D,
16034                            val,
16035                            decoder,
16036                            _inner_offset,
16037                            depth
16038                        )?;
16039                    } else {
16040                        unreachable!()
16041                    }
16042                }
16043                2 => {
16044                    #[allow(irrefutable_let_patterns)]
16045                    if let JoinParams::JoinerParameter(_) = self {
16046                        // Do nothing, read the value into the object
16047                    } else {
16048                        // Initialize `self` to the right variant
16049                        *self = JoinParams::JoinerParameter(fidl::new_empty!(
16050                            JoinerCommissioningParams,
16051                            D
16052                        ));
16053                    }
16054                    #[allow(irrefutable_let_patterns)]
16055                    if let JoinParams::JoinerParameter(ref mut val) = self {
16056                        fidl::decode!(
16057                            JoinerCommissioningParams,
16058                            D,
16059                            val,
16060                            decoder,
16061                            _inner_offset,
16062                            depth
16063                        )?;
16064                    } else {
16065                        unreachable!()
16066                    }
16067                }
16068                #[allow(deprecated)]
16069                ordinal => {
16070                    for _ in 0..num_handles {
16071                        decoder.drop_next_handle()?;
16072                    }
16073                    *self = JoinParams::__SourceBreaking { unknown_ordinal: ordinal };
16074                }
16075            }
16076            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
16077                return Err(fidl::Error::InvalidNumBytesInEnvelope);
16078            }
16079            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16080                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16081            }
16082            Ok(())
16083        }
16084    }
16085
16086    impl fidl::encoding::ValueTypeMarker for ProvisioningProgress {
16087        type Borrowed<'a> = &'a Self;
16088        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
16089            value
16090        }
16091    }
16092
16093    unsafe impl fidl::encoding::TypeMarker for ProvisioningProgress {
16094        type Owned = Self;
16095
16096        #[inline(always)]
16097        fn inline_align(_context: fidl::encoding::Context) -> usize {
16098            8
16099        }
16100
16101        #[inline(always)]
16102        fn inline_size(_context: fidl::encoding::Context) -> usize {
16103            16
16104        }
16105    }
16106
16107    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ProvisioningProgress, D>
16108        for &ProvisioningProgress
16109    {
16110        #[inline]
16111        unsafe fn encode(
16112            self,
16113            encoder: &mut fidl::encoding::Encoder<'_, D>,
16114            offset: usize,
16115            _depth: fidl::encoding::Depth,
16116        ) -> fidl::Result<()> {
16117            encoder.debug_check_bounds::<ProvisioningProgress>(offset);
16118            encoder.write_num::<u64>(self.ordinal(), offset);
16119            match self {
16120            ProvisioningProgress::Progress(ref val) => {
16121                fidl::encoding::encode_in_envelope::<f32, D>(
16122                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16123                    encoder, offset + 8, _depth
16124                )
16125            }
16126            ProvisioningProgress::Identity(ref val) => {
16127                fidl::encoding::encode_in_envelope::<fidl_fuchsia_lowpan_device__common::Identity, D>(
16128                    <fidl_fuchsia_lowpan_device__common::Identity as fidl::encoding::ValueTypeMarker>::borrow(val),
16129                    encoder, offset + 8, _depth
16130                )
16131            }
16132            ProvisioningProgress::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
16133        }
16134        }
16135    }
16136
16137    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ProvisioningProgress {
16138        #[inline(always)]
16139        fn new_empty() -> Self {
16140            Self::__SourceBreaking { unknown_ordinal: 0 }
16141        }
16142
16143        #[inline]
16144        unsafe fn decode(
16145            &mut self,
16146            decoder: &mut fidl::encoding::Decoder<'_, D>,
16147            offset: usize,
16148            mut depth: fidl::encoding::Depth,
16149        ) -> fidl::Result<()> {
16150            decoder.debug_check_bounds::<Self>(offset);
16151            #[allow(unused_variables)]
16152            let next_out_of_line = decoder.next_out_of_line();
16153            let handles_before = decoder.remaining_handles();
16154            let (ordinal, inlined, num_bytes, num_handles) =
16155                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
16156
16157            let member_inline_size = match ordinal {
16158            1 => <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16159            2 => <fidl_fuchsia_lowpan_device__common::Identity as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16160            0 => return Err(fidl::Error::UnknownUnionTag),
16161            _ => num_bytes as usize,
16162        };
16163
16164            if inlined != (member_inline_size <= 4) {
16165                return Err(fidl::Error::InvalidInlineBitInEnvelope);
16166            }
16167            let _inner_offset;
16168            if inlined {
16169                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
16170                _inner_offset = offset + 8;
16171            } else {
16172                depth.increment()?;
16173                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16174            }
16175            match ordinal {
16176                1 => {
16177                    #[allow(irrefutable_let_patterns)]
16178                    if let ProvisioningProgress::Progress(_) = self {
16179                        // Do nothing, read the value into the object
16180                    } else {
16181                        // Initialize `self` to the right variant
16182                        *self = ProvisioningProgress::Progress(fidl::new_empty!(f32, D));
16183                    }
16184                    #[allow(irrefutable_let_patterns)]
16185                    if let ProvisioningProgress::Progress(ref mut val) = self {
16186                        fidl::decode!(f32, D, val, decoder, _inner_offset, depth)?;
16187                    } else {
16188                        unreachable!()
16189                    }
16190                }
16191                2 => {
16192                    #[allow(irrefutable_let_patterns)]
16193                    if let ProvisioningProgress::Identity(_) = self {
16194                        // Do nothing, read the value into the object
16195                    } else {
16196                        // Initialize `self` to the right variant
16197                        *self = ProvisioningProgress::Identity(fidl::new_empty!(
16198                            fidl_fuchsia_lowpan_device__common::Identity,
16199                            D
16200                        ));
16201                    }
16202                    #[allow(irrefutable_let_patterns)]
16203                    if let ProvisioningProgress::Identity(ref mut val) = self {
16204                        fidl::decode!(
16205                            fidl_fuchsia_lowpan_device__common::Identity,
16206                            D,
16207                            val,
16208                            decoder,
16209                            _inner_offset,
16210                            depth
16211                        )?;
16212                    } else {
16213                        unreachable!()
16214                    }
16215                }
16216                #[allow(deprecated)]
16217                ordinal => {
16218                    for _ in 0..num_handles {
16219                        decoder.drop_next_handle()?;
16220                    }
16221                    *self = ProvisioningProgress::__SourceBreaking { unknown_ordinal: ordinal };
16222                }
16223            }
16224            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
16225                return Err(fidl::Error::InvalidNumBytesInEnvelope);
16226            }
16227            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16228                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16229            }
16230            Ok(())
16231        }
16232    }
16233}