fidl_fuchsia_net_interfaces_admin_common/
fidl_fuchsia_net_interfaces_admin_common.rs

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