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__common::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__common::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__common::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
974pub mod address_state_provider_ordinals {
975    pub const UPDATE_ADDRESS_PROPERTIES: u64 = 0x52bdf5ed96ef573c;
976    pub const WATCH_ADDRESS_ASSIGNMENT_STATE: u64 = 0x740bb58c1b2d3188;
977    pub const DETACH: u64 = 0xc752381d739622f;
978    pub const REMOVE: u64 = 0x554407fe183e78ad;
979    pub const ON_ADDRESS_ADDED: u64 = 0x624f6ea62cce189e;
980    pub const ON_ADDRESS_REMOVED: u64 = 0x2480eb672ffd5962;
981}
982
983pub mod control_ordinals {
984    pub const ADD_ADDRESS: u64 = 0x1349d36da453ce;
985    pub const REMOVE_ADDRESS: u64 = 0x213ba73da997a620;
986    pub const GET_ID: u64 = 0x2a2459768d9ecc6f;
987    pub const SET_CONFIGURATION: u64 = 0x573923b7b4bde27f;
988    pub const GET_CONFIGURATION: u64 = 0x5f5d239820bdcc65;
989    pub const ENABLE: u64 = 0x15c983d3a8ac0b98;
990    pub const DISABLE: u64 = 0x98d3a585d905473;
991    pub const DETACH: u64 = 0x78ee27518b2dbfa;
992    pub const GET_AUTHORIZATION_FOR_INTERFACE: u64 = 0xc1de2ab60b5cb9e;
993    pub const REMOVE: u64 = 0x13aab8bbecc7ff0b;
994    pub const ON_INTERFACE_REMOVED: u64 = 0x800d39e76c1cddd;
995}
996
997pub mod device_control_ordinals {
998    pub const CREATE_INTERFACE: u64 = 0x4ff8be7351d12f86;
999    pub const DETACH: u64 = 0x57489f1554d489d2;
1000}
1001
1002pub mod installer_ordinals {
1003    pub const INSTALL_DEVICE: u64 = 0x3e84524dcecab23a;
1004    pub const INSTALL_BLACKHOLE_INTERFACE: u64 = 0x2ce57e87cdbcb809;
1005}
1006
1007mod internal {
1008    use super::*;
1009    unsafe impl fidl::encoding::TypeMarker for AddressRemovalReason {
1010        type Owned = Self;
1011
1012        #[inline(always)]
1013        fn inline_align(_context: fidl::encoding::Context) -> usize {
1014            std::mem::align_of::<u32>()
1015        }
1016
1017        #[inline(always)]
1018        fn inline_size(_context: fidl::encoding::Context) -> usize {
1019            std::mem::size_of::<u32>()
1020        }
1021
1022        #[inline(always)]
1023        fn encode_is_copy() -> bool {
1024            true
1025        }
1026
1027        #[inline(always)]
1028        fn decode_is_copy() -> bool {
1029            false
1030        }
1031    }
1032
1033    impl fidl::encoding::ValueTypeMarker for AddressRemovalReason {
1034        type Borrowed<'a> = Self;
1035        #[inline(always)]
1036        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1037            *value
1038        }
1039    }
1040
1041    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1042        for AddressRemovalReason
1043    {
1044        #[inline]
1045        unsafe fn encode(
1046            self,
1047            encoder: &mut fidl::encoding::Encoder<'_, D>,
1048            offset: usize,
1049            _depth: fidl::encoding::Depth,
1050        ) -> fidl::Result<()> {
1051            encoder.debug_check_bounds::<Self>(offset);
1052            encoder.write_num(self.into_primitive(), offset);
1053            Ok(())
1054        }
1055    }
1056
1057    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AddressRemovalReason {
1058        #[inline(always)]
1059        fn new_empty() -> Self {
1060            Self::Invalid
1061        }
1062
1063        #[inline]
1064        unsafe fn decode(
1065            &mut self,
1066            decoder: &mut fidl::encoding::Decoder<'_, D>,
1067            offset: usize,
1068            _depth: fidl::encoding::Depth,
1069        ) -> fidl::Result<()> {
1070            decoder.debug_check_bounds::<Self>(offset);
1071            let prim = decoder.read_num::<u32>(offset);
1072
1073            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1074            Ok(())
1075        }
1076    }
1077    unsafe impl fidl::encoding::TypeMarker for ControlDisableError {
1078        type Owned = Self;
1079
1080        #[inline(always)]
1081        fn inline_align(_context: fidl::encoding::Context) -> usize {
1082            std::mem::align_of::<u32>()
1083        }
1084
1085        #[inline(always)]
1086        fn inline_size(_context: fidl::encoding::Context) -> usize {
1087            std::mem::size_of::<u32>()
1088        }
1089
1090        #[inline(always)]
1091        fn encode_is_copy() -> bool {
1092            false
1093        }
1094
1095        #[inline(always)]
1096        fn decode_is_copy() -> bool {
1097            false
1098        }
1099    }
1100
1101    impl fidl::encoding::ValueTypeMarker for ControlDisableError {
1102        type Borrowed<'a> = Self;
1103        #[inline(always)]
1104        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1105            *value
1106        }
1107    }
1108
1109    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1110        for ControlDisableError
1111    {
1112        #[inline]
1113        unsafe fn encode(
1114            self,
1115            encoder: &mut fidl::encoding::Encoder<'_, D>,
1116            offset: usize,
1117            _depth: fidl::encoding::Depth,
1118        ) -> fidl::Result<()> {
1119            encoder.debug_check_bounds::<Self>(offset);
1120            encoder.write_num(self.into_primitive(), offset);
1121            Ok(())
1122        }
1123    }
1124
1125    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlDisableError {
1126        #[inline(always)]
1127        fn new_empty() -> Self {
1128            Self::unknown()
1129        }
1130
1131        #[inline]
1132        unsafe fn decode(
1133            &mut self,
1134            decoder: &mut fidl::encoding::Decoder<'_, D>,
1135            offset: usize,
1136            _depth: fidl::encoding::Depth,
1137        ) -> fidl::Result<()> {
1138            decoder.debug_check_bounds::<Self>(offset);
1139            let prim = decoder.read_num::<u32>(offset);
1140
1141            *self = Self::from_primitive_allow_unknown(prim);
1142            Ok(())
1143        }
1144    }
1145    unsafe impl fidl::encoding::TypeMarker for ControlEnableError {
1146        type Owned = Self;
1147
1148        #[inline(always)]
1149        fn inline_align(_context: fidl::encoding::Context) -> usize {
1150            std::mem::align_of::<u32>()
1151        }
1152
1153        #[inline(always)]
1154        fn inline_size(_context: fidl::encoding::Context) -> usize {
1155            std::mem::size_of::<u32>()
1156        }
1157
1158        #[inline(always)]
1159        fn encode_is_copy() -> bool {
1160            false
1161        }
1162
1163        #[inline(always)]
1164        fn decode_is_copy() -> bool {
1165            false
1166        }
1167    }
1168
1169    impl fidl::encoding::ValueTypeMarker for ControlEnableError {
1170        type Borrowed<'a> = Self;
1171        #[inline(always)]
1172        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1173            *value
1174        }
1175    }
1176
1177    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1178        for ControlEnableError
1179    {
1180        #[inline]
1181        unsafe fn encode(
1182            self,
1183            encoder: &mut fidl::encoding::Encoder<'_, D>,
1184            offset: usize,
1185            _depth: fidl::encoding::Depth,
1186        ) -> fidl::Result<()> {
1187            encoder.debug_check_bounds::<Self>(offset);
1188            encoder.write_num(self.into_primitive(), offset);
1189            Ok(())
1190        }
1191    }
1192
1193    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlEnableError {
1194        #[inline(always)]
1195        fn new_empty() -> Self {
1196            Self::unknown()
1197        }
1198
1199        #[inline]
1200        unsafe fn decode(
1201            &mut self,
1202            decoder: &mut fidl::encoding::Decoder<'_, D>,
1203            offset: usize,
1204            _depth: fidl::encoding::Depth,
1205        ) -> fidl::Result<()> {
1206            decoder.debug_check_bounds::<Self>(offset);
1207            let prim = decoder.read_num::<u32>(offset);
1208
1209            *self = Self::from_primitive_allow_unknown(prim);
1210            Ok(())
1211        }
1212    }
1213    unsafe impl fidl::encoding::TypeMarker for ControlGetConfigurationError {
1214        type Owned = Self;
1215
1216        #[inline(always)]
1217        fn inline_align(_context: fidl::encoding::Context) -> usize {
1218            std::mem::align_of::<u32>()
1219        }
1220
1221        #[inline(always)]
1222        fn inline_size(_context: fidl::encoding::Context) -> usize {
1223            std::mem::size_of::<u32>()
1224        }
1225
1226        #[inline(always)]
1227        fn encode_is_copy() -> bool {
1228            false
1229        }
1230
1231        #[inline(always)]
1232        fn decode_is_copy() -> bool {
1233            false
1234        }
1235    }
1236
1237    impl fidl::encoding::ValueTypeMarker for ControlGetConfigurationError {
1238        type Borrowed<'a> = Self;
1239        #[inline(always)]
1240        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1241            *value
1242        }
1243    }
1244
1245    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1246        for ControlGetConfigurationError
1247    {
1248        #[inline]
1249        unsafe fn encode(
1250            self,
1251            encoder: &mut fidl::encoding::Encoder<'_, D>,
1252            offset: usize,
1253            _depth: fidl::encoding::Depth,
1254        ) -> fidl::Result<()> {
1255            encoder.debug_check_bounds::<Self>(offset);
1256            encoder.write_num(self.into_primitive(), offset);
1257            Ok(())
1258        }
1259    }
1260
1261    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1262        for ControlGetConfigurationError
1263    {
1264        #[inline(always)]
1265        fn new_empty() -> Self {
1266            Self::unknown()
1267        }
1268
1269        #[inline]
1270        unsafe fn decode(
1271            &mut self,
1272            decoder: &mut fidl::encoding::Decoder<'_, D>,
1273            offset: usize,
1274            _depth: fidl::encoding::Depth,
1275        ) -> fidl::Result<()> {
1276            decoder.debug_check_bounds::<Self>(offset);
1277            let prim = decoder.read_num::<u32>(offset);
1278
1279            *self = Self::from_primitive_allow_unknown(prim);
1280            Ok(())
1281        }
1282    }
1283    unsafe impl fidl::encoding::TypeMarker for ControlRemoveAddressError {
1284        type Owned = Self;
1285
1286        #[inline(always)]
1287        fn inline_align(_context: fidl::encoding::Context) -> usize {
1288            std::mem::align_of::<u32>()
1289        }
1290
1291        #[inline(always)]
1292        fn inline_size(_context: fidl::encoding::Context) -> usize {
1293            std::mem::size_of::<u32>()
1294        }
1295
1296        #[inline(always)]
1297        fn encode_is_copy() -> bool {
1298            false
1299        }
1300
1301        #[inline(always)]
1302        fn decode_is_copy() -> bool {
1303            false
1304        }
1305    }
1306
1307    impl fidl::encoding::ValueTypeMarker for ControlRemoveAddressError {
1308        type Borrowed<'a> = Self;
1309        #[inline(always)]
1310        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1311            *value
1312        }
1313    }
1314
1315    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1316        for ControlRemoveAddressError
1317    {
1318        #[inline]
1319        unsafe fn encode(
1320            self,
1321            encoder: &mut fidl::encoding::Encoder<'_, D>,
1322            offset: usize,
1323            _depth: fidl::encoding::Depth,
1324        ) -> fidl::Result<()> {
1325            encoder.debug_check_bounds::<Self>(offset);
1326            encoder.write_num(self.into_primitive(), offset);
1327            Ok(())
1328        }
1329    }
1330
1331    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1332        for ControlRemoveAddressError
1333    {
1334        #[inline(always)]
1335        fn new_empty() -> Self {
1336            Self::unknown()
1337        }
1338
1339        #[inline]
1340        unsafe fn decode(
1341            &mut self,
1342            decoder: &mut fidl::encoding::Decoder<'_, D>,
1343            offset: usize,
1344            _depth: fidl::encoding::Depth,
1345        ) -> fidl::Result<()> {
1346            decoder.debug_check_bounds::<Self>(offset);
1347            let prim = decoder.read_num::<u32>(offset);
1348
1349            *self = Self::from_primitive_allow_unknown(prim);
1350            Ok(())
1351        }
1352    }
1353    unsafe impl fidl::encoding::TypeMarker for ControlRemoveError {
1354        type Owned = Self;
1355
1356        #[inline(always)]
1357        fn inline_align(_context: fidl::encoding::Context) -> usize {
1358            std::mem::align_of::<u32>()
1359        }
1360
1361        #[inline(always)]
1362        fn inline_size(_context: fidl::encoding::Context) -> usize {
1363            std::mem::size_of::<u32>()
1364        }
1365
1366        #[inline(always)]
1367        fn encode_is_copy() -> bool {
1368            false
1369        }
1370
1371        #[inline(always)]
1372        fn decode_is_copy() -> bool {
1373            false
1374        }
1375    }
1376
1377    impl fidl::encoding::ValueTypeMarker for ControlRemoveError {
1378        type Borrowed<'a> = Self;
1379        #[inline(always)]
1380        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1381            *value
1382        }
1383    }
1384
1385    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1386        for ControlRemoveError
1387    {
1388        #[inline]
1389        unsafe fn encode(
1390            self,
1391            encoder: &mut fidl::encoding::Encoder<'_, D>,
1392            offset: usize,
1393            _depth: fidl::encoding::Depth,
1394        ) -> fidl::Result<()> {
1395            encoder.debug_check_bounds::<Self>(offset);
1396            encoder.write_num(self.into_primitive(), offset);
1397            Ok(())
1398        }
1399    }
1400
1401    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlRemoveError {
1402        #[inline(always)]
1403        fn new_empty() -> Self {
1404            Self::unknown()
1405        }
1406
1407        #[inline]
1408        unsafe fn decode(
1409            &mut self,
1410            decoder: &mut fidl::encoding::Decoder<'_, D>,
1411            offset: usize,
1412            _depth: fidl::encoding::Depth,
1413        ) -> fidl::Result<()> {
1414            decoder.debug_check_bounds::<Self>(offset);
1415            let prim = decoder.read_num::<u32>(offset);
1416
1417            *self = Self::from_primitive_allow_unknown(prim);
1418            Ok(())
1419        }
1420    }
1421    unsafe impl fidl::encoding::TypeMarker for ControlSetConfigurationError {
1422        type Owned = Self;
1423
1424        #[inline(always)]
1425        fn inline_align(_context: fidl::encoding::Context) -> usize {
1426            std::mem::align_of::<u32>()
1427        }
1428
1429        #[inline(always)]
1430        fn inline_size(_context: fidl::encoding::Context) -> usize {
1431            std::mem::size_of::<u32>()
1432        }
1433
1434        #[inline(always)]
1435        fn encode_is_copy() -> bool {
1436            false
1437        }
1438
1439        #[inline(always)]
1440        fn decode_is_copy() -> bool {
1441            false
1442        }
1443    }
1444
1445    impl fidl::encoding::ValueTypeMarker for ControlSetConfigurationError {
1446        type Borrowed<'a> = Self;
1447        #[inline(always)]
1448        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1449            *value
1450        }
1451    }
1452
1453    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1454        for ControlSetConfigurationError
1455    {
1456        #[inline]
1457        unsafe fn encode(
1458            self,
1459            encoder: &mut fidl::encoding::Encoder<'_, D>,
1460            offset: usize,
1461            _depth: fidl::encoding::Depth,
1462        ) -> fidl::Result<()> {
1463            encoder.debug_check_bounds::<Self>(offset);
1464            encoder.write_num(self.into_primitive(), offset);
1465            Ok(())
1466        }
1467    }
1468
1469    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1470        for ControlSetConfigurationError
1471    {
1472        #[inline(always)]
1473        fn new_empty() -> Self {
1474            Self::unknown()
1475        }
1476
1477        #[inline]
1478        unsafe fn decode(
1479            &mut self,
1480            decoder: &mut fidl::encoding::Decoder<'_, D>,
1481            offset: usize,
1482            _depth: fidl::encoding::Depth,
1483        ) -> fidl::Result<()> {
1484            decoder.debug_check_bounds::<Self>(offset);
1485            let prim = decoder.read_num::<u32>(offset);
1486
1487            *self = Self::from_primitive_allow_unknown(prim);
1488            Ok(())
1489        }
1490    }
1491    unsafe impl fidl::encoding::TypeMarker for IgmpVersion {
1492        type Owned = Self;
1493
1494        #[inline(always)]
1495        fn inline_align(_context: fidl::encoding::Context) -> usize {
1496            std::mem::align_of::<u8>()
1497        }
1498
1499        #[inline(always)]
1500        fn inline_size(_context: fidl::encoding::Context) -> usize {
1501            std::mem::size_of::<u8>()
1502        }
1503
1504        #[inline(always)]
1505        fn encode_is_copy() -> bool {
1506            false
1507        }
1508
1509        #[inline(always)]
1510        fn decode_is_copy() -> bool {
1511            false
1512        }
1513    }
1514
1515    impl fidl::encoding::ValueTypeMarker for IgmpVersion {
1516        type Borrowed<'a> = Self;
1517        #[inline(always)]
1518        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1519            *value
1520        }
1521    }
1522
1523    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for IgmpVersion {
1524        #[inline]
1525        unsafe fn encode(
1526            self,
1527            encoder: &mut fidl::encoding::Encoder<'_, D>,
1528            offset: usize,
1529            _depth: fidl::encoding::Depth,
1530        ) -> fidl::Result<()> {
1531            encoder.debug_check_bounds::<Self>(offset);
1532            encoder.write_num(self.into_primitive(), offset);
1533            Ok(())
1534        }
1535    }
1536
1537    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IgmpVersion {
1538        #[inline(always)]
1539        fn new_empty() -> Self {
1540            Self::unknown()
1541        }
1542
1543        #[inline]
1544        unsafe fn decode(
1545            &mut self,
1546            decoder: &mut fidl::encoding::Decoder<'_, D>,
1547            offset: usize,
1548            _depth: fidl::encoding::Depth,
1549        ) -> fidl::Result<()> {
1550            decoder.debug_check_bounds::<Self>(offset);
1551            let prim = decoder.read_num::<u8>(offset);
1552
1553            *self = Self::from_primitive_allow_unknown(prim);
1554            Ok(())
1555        }
1556    }
1557    unsafe impl fidl::encoding::TypeMarker for InterfaceRemovedReason {
1558        type Owned = Self;
1559
1560        #[inline(always)]
1561        fn inline_align(_context: fidl::encoding::Context) -> usize {
1562            std::mem::align_of::<u32>()
1563        }
1564
1565        #[inline(always)]
1566        fn inline_size(_context: fidl::encoding::Context) -> usize {
1567            std::mem::size_of::<u32>()
1568        }
1569
1570        #[inline(always)]
1571        fn encode_is_copy() -> bool {
1572            false
1573        }
1574
1575        #[inline(always)]
1576        fn decode_is_copy() -> bool {
1577            false
1578        }
1579    }
1580
1581    impl fidl::encoding::ValueTypeMarker for InterfaceRemovedReason {
1582        type Borrowed<'a> = Self;
1583        #[inline(always)]
1584        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1585            *value
1586        }
1587    }
1588
1589    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1590        for InterfaceRemovedReason
1591    {
1592        #[inline]
1593        unsafe fn encode(
1594            self,
1595            encoder: &mut fidl::encoding::Encoder<'_, D>,
1596            offset: usize,
1597            _depth: fidl::encoding::Depth,
1598        ) -> fidl::Result<()> {
1599            encoder.debug_check_bounds::<Self>(offset);
1600            encoder.write_num(self.into_primitive(), offset);
1601            Ok(())
1602        }
1603    }
1604
1605    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1606        for InterfaceRemovedReason
1607    {
1608        #[inline(always)]
1609        fn new_empty() -> Self {
1610            Self::unknown()
1611        }
1612
1613        #[inline]
1614        unsafe fn decode(
1615            &mut self,
1616            decoder: &mut fidl::encoding::Decoder<'_, D>,
1617            offset: usize,
1618            _depth: fidl::encoding::Depth,
1619        ) -> fidl::Result<()> {
1620            decoder.debug_check_bounds::<Self>(offset);
1621            let prim = decoder.read_num::<u32>(offset);
1622
1623            *self = Self::from_primitive_allow_unknown(prim);
1624            Ok(())
1625        }
1626    }
1627    unsafe impl fidl::encoding::TypeMarker for MldVersion {
1628        type Owned = Self;
1629
1630        #[inline(always)]
1631        fn inline_align(_context: fidl::encoding::Context) -> usize {
1632            std::mem::align_of::<u8>()
1633        }
1634
1635        #[inline(always)]
1636        fn inline_size(_context: fidl::encoding::Context) -> usize {
1637            std::mem::size_of::<u8>()
1638        }
1639
1640        #[inline(always)]
1641        fn encode_is_copy() -> bool {
1642            false
1643        }
1644
1645        #[inline(always)]
1646        fn decode_is_copy() -> bool {
1647            false
1648        }
1649    }
1650
1651    impl fidl::encoding::ValueTypeMarker for MldVersion {
1652        type Borrowed<'a> = Self;
1653        #[inline(always)]
1654        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1655            *value
1656        }
1657    }
1658
1659    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for MldVersion {
1660        #[inline]
1661        unsafe fn encode(
1662            self,
1663            encoder: &mut fidl::encoding::Encoder<'_, D>,
1664            offset: usize,
1665            _depth: fidl::encoding::Depth,
1666        ) -> fidl::Result<()> {
1667            encoder.debug_check_bounds::<Self>(offset);
1668            encoder.write_num(self.into_primitive(), offset);
1669            Ok(())
1670        }
1671    }
1672
1673    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MldVersion {
1674        #[inline(always)]
1675        fn new_empty() -> Self {
1676            Self::unknown()
1677        }
1678
1679        #[inline]
1680        unsafe fn decode(
1681            &mut self,
1682            decoder: &mut fidl::encoding::Decoder<'_, D>,
1683            offset: usize,
1684            _depth: fidl::encoding::Depth,
1685        ) -> fidl::Result<()> {
1686            decoder.debug_check_bounds::<Self>(offset);
1687            let prim = decoder.read_num::<u8>(offset);
1688
1689            *self = Self::from_primitive_allow_unknown(prim);
1690            Ok(())
1691        }
1692    }
1693
1694    impl fidl::encoding::ValueTypeMarker for AddressStateProviderOnAddressRemovedRequest {
1695        type Borrowed<'a> = &'a Self;
1696        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1697            value
1698        }
1699    }
1700
1701    unsafe impl fidl::encoding::TypeMarker for AddressStateProviderOnAddressRemovedRequest {
1702        type Owned = Self;
1703
1704        #[inline(always)]
1705        fn inline_align(_context: fidl::encoding::Context) -> usize {
1706            4
1707        }
1708
1709        #[inline(always)]
1710        fn inline_size(_context: fidl::encoding::Context) -> usize {
1711            4
1712        }
1713    }
1714
1715    unsafe impl<D: fidl::encoding::ResourceDialect>
1716        fidl::encoding::Encode<AddressStateProviderOnAddressRemovedRequest, D>
1717        for &AddressStateProviderOnAddressRemovedRequest
1718    {
1719        #[inline]
1720        unsafe fn encode(
1721            self,
1722            encoder: &mut fidl::encoding::Encoder<'_, D>,
1723            offset: usize,
1724            _depth: fidl::encoding::Depth,
1725        ) -> fidl::Result<()> {
1726            encoder.debug_check_bounds::<AddressStateProviderOnAddressRemovedRequest>(offset);
1727            // Delegate to tuple encoding.
1728            fidl::encoding::Encode::<AddressStateProviderOnAddressRemovedRequest, D>::encode(
1729                (<AddressRemovalReason as fidl::encoding::ValueTypeMarker>::borrow(&self.error),),
1730                encoder,
1731                offset,
1732                _depth,
1733            )
1734        }
1735    }
1736    unsafe impl<
1737            D: fidl::encoding::ResourceDialect,
1738            T0: fidl::encoding::Encode<AddressRemovalReason, D>,
1739        > fidl::encoding::Encode<AddressStateProviderOnAddressRemovedRequest, D> for (T0,)
1740    {
1741        #[inline]
1742        unsafe fn encode(
1743            self,
1744            encoder: &mut fidl::encoding::Encoder<'_, D>,
1745            offset: usize,
1746            depth: fidl::encoding::Depth,
1747        ) -> fidl::Result<()> {
1748            encoder.debug_check_bounds::<AddressStateProviderOnAddressRemovedRequest>(offset);
1749            // Zero out padding regions. There's no need to apply masks
1750            // because the unmasked parts will be overwritten by fields.
1751            // Write the fields.
1752            self.0.encode(encoder, offset + 0, depth)?;
1753            Ok(())
1754        }
1755    }
1756
1757    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1758        for AddressStateProviderOnAddressRemovedRequest
1759    {
1760        #[inline(always)]
1761        fn new_empty() -> Self {
1762            Self { error: fidl::new_empty!(AddressRemovalReason, D) }
1763        }
1764
1765        #[inline]
1766        unsafe fn decode(
1767            &mut self,
1768            decoder: &mut fidl::encoding::Decoder<'_, D>,
1769            offset: usize,
1770            _depth: fidl::encoding::Depth,
1771        ) -> fidl::Result<()> {
1772            decoder.debug_check_bounds::<Self>(offset);
1773            // Verify that padding bytes are zero.
1774            fidl::decode!(AddressRemovalReason, D, &mut self.error, decoder, offset + 0, _depth)?;
1775            Ok(())
1776        }
1777    }
1778
1779    impl fidl::encoding::ValueTypeMarker for AddressStateProviderUpdateAddressPropertiesRequest {
1780        type Borrowed<'a> = &'a Self;
1781        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1782            value
1783        }
1784    }
1785
1786    unsafe impl fidl::encoding::TypeMarker for AddressStateProviderUpdateAddressPropertiesRequest {
1787        type Owned = Self;
1788
1789        #[inline(always)]
1790        fn inline_align(_context: fidl::encoding::Context) -> usize {
1791            8
1792        }
1793
1794        #[inline(always)]
1795        fn inline_size(_context: fidl::encoding::Context) -> usize {
1796            16
1797        }
1798    }
1799
1800    unsafe impl<D: fidl::encoding::ResourceDialect>
1801        fidl::encoding::Encode<AddressStateProviderUpdateAddressPropertiesRequest, D>
1802        for &AddressStateProviderUpdateAddressPropertiesRequest
1803    {
1804        #[inline]
1805        unsafe fn encode(
1806            self,
1807            encoder: &mut fidl::encoding::Encoder<'_, D>,
1808            offset: usize,
1809            _depth: fidl::encoding::Depth,
1810        ) -> fidl::Result<()> {
1811            encoder
1812                .debug_check_bounds::<AddressStateProviderUpdateAddressPropertiesRequest>(offset);
1813            // Delegate to tuple encoding.
1814            fidl::encoding::Encode::<AddressStateProviderUpdateAddressPropertiesRequest, D>::encode(
1815                (<AddressProperties as fidl::encoding::ValueTypeMarker>::borrow(
1816                    &self.address_properties,
1817                ),),
1818                encoder,
1819                offset,
1820                _depth,
1821            )
1822        }
1823    }
1824    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<AddressProperties, D>>
1825        fidl::encoding::Encode<AddressStateProviderUpdateAddressPropertiesRequest, D> for (T0,)
1826    {
1827        #[inline]
1828        unsafe fn encode(
1829            self,
1830            encoder: &mut fidl::encoding::Encoder<'_, D>,
1831            offset: usize,
1832            depth: fidl::encoding::Depth,
1833        ) -> fidl::Result<()> {
1834            encoder
1835                .debug_check_bounds::<AddressStateProviderUpdateAddressPropertiesRequest>(offset);
1836            // Zero out padding regions. There's no need to apply masks
1837            // because the unmasked parts will be overwritten by fields.
1838            // Write the fields.
1839            self.0.encode(encoder, offset + 0, depth)?;
1840            Ok(())
1841        }
1842    }
1843
1844    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1845        for AddressStateProviderUpdateAddressPropertiesRequest
1846    {
1847        #[inline(always)]
1848        fn new_empty() -> Self {
1849            Self { address_properties: fidl::new_empty!(AddressProperties, D) }
1850        }
1851
1852        #[inline]
1853        unsafe fn decode(
1854            &mut self,
1855            decoder: &mut fidl::encoding::Decoder<'_, D>,
1856            offset: usize,
1857            _depth: fidl::encoding::Depth,
1858        ) -> fidl::Result<()> {
1859            decoder.debug_check_bounds::<Self>(offset);
1860            // Verify that padding bytes are zero.
1861            fidl::decode!(
1862                AddressProperties,
1863                D,
1864                &mut self.address_properties,
1865                decoder,
1866                offset + 0,
1867                _depth
1868            )?;
1869            Ok(())
1870        }
1871    }
1872
1873    impl fidl::encoding::ValueTypeMarker for AddressStateProviderWatchAddressAssignmentStateResponse {
1874        type Borrowed<'a> = &'a Self;
1875        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1876            value
1877        }
1878    }
1879
1880    unsafe impl fidl::encoding::TypeMarker for AddressStateProviderWatchAddressAssignmentStateResponse {
1881        type Owned = Self;
1882
1883        #[inline(always)]
1884        fn inline_align(_context: fidl::encoding::Context) -> usize {
1885            4
1886        }
1887
1888        #[inline(always)]
1889        fn inline_size(_context: fidl::encoding::Context) -> usize {
1890            4
1891        }
1892    }
1893
1894    unsafe impl<D: fidl::encoding::ResourceDialect>
1895        fidl::encoding::Encode<AddressStateProviderWatchAddressAssignmentStateResponse, D>
1896        for &AddressStateProviderWatchAddressAssignmentStateResponse
1897    {
1898        #[inline]
1899        unsafe fn encode(
1900            self,
1901            encoder: &mut fidl::encoding::Encoder<'_, D>,
1902            offset: usize,
1903            _depth: fidl::encoding::Depth,
1904        ) -> fidl::Result<()> {
1905            encoder.debug_check_bounds::<AddressStateProviderWatchAddressAssignmentStateResponse>(
1906                offset,
1907            );
1908            // Delegate to tuple encoding.
1909            fidl::encoding::Encode::<AddressStateProviderWatchAddressAssignmentStateResponse, D>::encode(
1910                (
1911                    <fidl_fuchsia_net_interfaces__common::AddressAssignmentState as fidl::encoding::ValueTypeMarker>::borrow(&self.assignment_state),
1912                ),
1913                encoder, offset, _depth
1914            )
1915        }
1916    }
1917    unsafe impl<
1918            D: fidl::encoding::ResourceDialect,
1919            T0: fidl::encoding::Encode<fidl_fuchsia_net_interfaces__common::AddressAssignmentState, D>,
1920        > fidl::encoding::Encode<AddressStateProviderWatchAddressAssignmentStateResponse, D>
1921        for (T0,)
1922    {
1923        #[inline]
1924        unsafe fn encode(
1925            self,
1926            encoder: &mut fidl::encoding::Encoder<'_, D>,
1927            offset: usize,
1928            depth: fidl::encoding::Depth,
1929        ) -> fidl::Result<()> {
1930            encoder.debug_check_bounds::<AddressStateProviderWatchAddressAssignmentStateResponse>(
1931                offset,
1932            );
1933            // Zero out padding regions. There's no need to apply masks
1934            // because the unmasked parts will be overwritten by fields.
1935            // Write the fields.
1936            self.0.encode(encoder, offset + 0, depth)?;
1937            Ok(())
1938        }
1939    }
1940
1941    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1942        for AddressStateProviderWatchAddressAssignmentStateResponse
1943    {
1944        #[inline(always)]
1945        fn new_empty() -> Self {
1946            Self {
1947                assignment_state: fidl::new_empty!(
1948                    fidl_fuchsia_net_interfaces__common::AddressAssignmentState,
1949                    D
1950                ),
1951            }
1952        }
1953
1954        #[inline]
1955        unsafe fn decode(
1956            &mut self,
1957            decoder: &mut fidl::encoding::Decoder<'_, D>,
1958            offset: usize,
1959            _depth: fidl::encoding::Depth,
1960        ) -> fidl::Result<()> {
1961            decoder.debug_check_bounds::<Self>(offset);
1962            // Verify that padding bytes are zero.
1963            fidl::decode!(
1964                fidl_fuchsia_net_interfaces__common::AddressAssignmentState,
1965                D,
1966                &mut self.assignment_state,
1967                decoder,
1968                offset + 0,
1969                _depth
1970            )?;
1971            Ok(())
1972        }
1973    }
1974
1975    impl fidl::encoding::ValueTypeMarker for ControlGetIdResponse {
1976        type Borrowed<'a> = &'a Self;
1977        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1978            value
1979        }
1980    }
1981
1982    unsafe impl fidl::encoding::TypeMarker for ControlGetIdResponse {
1983        type Owned = Self;
1984
1985        #[inline(always)]
1986        fn inline_align(_context: fidl::encoding::Context) -> usize {
1987            8
1988        }
1989
1990        #[inline(always)]
1991        fn inline_size(_context: fidl::encoding::Context) -> usize {
1992            8
1993        }
1994        #[inline(always)]
1995        fn encode_is_copy() -> bool {
1996            true
1997        }
1998
1999        #[inline(always)]
2000        fn decode_is_copy() -> bool {
2001            true
2002        }
2003    }
2004
2005    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ControlGetIdResponse, D>
2006        for &ControlGetIdResponse
2007    {
2008        #[inline]
2009        unsafe fn encode(
2010            self,
2011            encoder: &mut fidl::encoding::Encoder<'_, D>,
2012            offset: usize,
2013            _depth: fidl::encoding::Depth,
2014        ) -> fidl::Result<()> {
2015            encoder.debug_check_bounds::<ControlGetIdResponse>(offset);
2016            unsafe {
2017                // Copy the object into the buffer.
2018                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2019                (buf_ptr as *mut ControlGetIdResponse)
2020                    .write_unaligned((self as *const ControlGetIdResponse).read());
2021                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2022                // done second because the memcpy will write garbage to these bytes.
2023            }
2024            Ok(())
2025        }
2026    }
2027    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
2028        fidl::encoding::Encode<ControlGetIdResponse, D> for (T0,)
2029    {
2030        #[inline]
2031        unsafe fn encode(
2032            self,
2033            encoder: &mut fidl::encoding::Encoder<'_, D>,
2034            offset: usize,
2035            depth: fidl::encoding::Depth,
2036        ) -> fidl::Result<()> {
2037            encoder.debug_check_bounds::<ControlGetIdResponse>(offset);
2038            // Zero out padding regions. There's no need to apply masks
2039            // because the unmasked parts will be overwritten by fields.
2040            // Write the fields.
2041            self.0.encode(encoder, offset + 0, depth)?;
2042            Ok(())
2043        }
2044    }
2045
2046    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlGetIdResponse {
2047        #[inline(always)]
2048        fn new_empty() -> Self {
2049            Self { id: fidl::new_empty!(u64, D) }
2050        }
2051
2052        #[inline]
2053        unsafe fn decode(
2054            &mut self,
2055            decoder: &mut fidl::encoding::Decoder<'_, D>,
2056            offset: usize,
2057            _depth: fidl::encoding::Depth,
2058        ) -> fidl::Result<()> {
2059            decoder.debug_check_bounds::<Self>(offset);
2060            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2061            // Verify that padding bytes are zero.
2062            // Copy from the buffer into the object.
2063            unsafe {
2064                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
2065            }
2066            Ok(())
2067        }
2068    }
2069
2070    impl fidl::encoding::ValueTypeMarker for ControlOnInterfaceRemovedRequest {
2071        type Borrowed<'a> = &'a Self;
2072        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2073            value
2074        }
2075    }
2076
2077    unsafe impl fidl::encoding::TypeMarker for ControlOnInterfaceRemovedRequest {
2078        type Owned = Self;
2079
2080        #[inline(always)]
2081        fn inline_align(_context: fidl::encoding::Context) -> usize {
2082            4
2083        }
2084
2085        #[inline(always)]
2086        fn inline_size(_context: fidl::encoding::Context) -> usize {
2087            4
2088        }
2089    }
2090
2091    unsafe impl<D: fidl::encoding::ResourceDialect>
2092        fidl::encoding::Encode<ControlOnInterfaceRemovedRequest, D>
2093        for &ControlOnInterfaceRemovedRequest
2094    {
2095        #[inline]
2096        unsafe fn encode(
2097            self,
2098            encoder: &mut fidl::encoding::Encoder<'_, D>,
2099            offset: usize,
2100            _depth: fidl::encoding::Depth,
2101        ) -> fidl::Result<()> {
2102            encoder.debug_check_bounds::<ControlOnInterfaceRemovedRequest>(offset);
2103            // Delegate to tuple encoding.
2104            fidl::encoding::Encode::<ControlOnInterfaceRemovedRequest, D>::encode(
2105                (<InterfaceRemovedReason as fidl::encoding::ValueTypeMarker>::borrow(&self.reason),),
2106                encoder,
2107                offset,
2108                _depth,
2109            )
2110        }
2111    }
2112    unsafe impl<
2113            D: fidl::encoding::ResourceDialect,
2114            T0: fidl::encoding::Encode<InterfaceRemovedReason, D>,
2115        > fidl::encoding::Encode<ControlOnInterfaceRemovedRequest, D> for (T0,)
2116    {
2117        #[inline]
2118        unsafe fn encode(
2119            self,
2120            encoder: &mut fidl::encoding::Encoder<'_, D>,
2121            offset: usize,
2122            depth: fidl::encoding::Depth,
2123        ) -> fidl::Result<()> {
2124            encoder.debug_check_bounds::<ControlOnInterfaceRemovedRequest>(offset);
2125            // Zero out padding regions. There's no need to apply masks
2126            // because the unmasked parts will be overwritten by fields.
2127            // Write the fields.
2128            self.0.encode(encoder, offset + 0, depth)?;
2129            Ok(())
2130        }
2131    }
2132
2133    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2134        for ControlOnInterfaceRemovedRequest
2135    {
2136        #[inline(always)]
2137        fn new_empty() -> Self {
2138            Self { reason: fidl::new_empty!(InterfaceRemovedReason, D) }
2139        }
2140
2141        #[inline]
2142        unsafe fn decode(
2143            &mut self,
2144            decoder: &mut fidl::encoding::Decoder<'_, D>,
2145            offset: usize,
2146            _depth: fidl::encoding::Depth,
2147        ) -> fidl::Result<()> {
2148            decoder.debug_check_bounds::<Self>(offset);
2149            // Verify that padding bytes are zero.
2150            fidl::decode!(
2151                InterfaceRemovedReason,
2152                D,
2153                &mut self.reason,
2154                decoder,
2155                offset + 0,
2156                _depth
2157            )?;
2158            Ok(())
2159        }
2160    }
2161
2162    impl fidl::encoding::ValueTypeMarker for ControlRemoveAddressRequest {
2163        type Borrowed<'a> = &'a Self;
2164        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2165            value
2166        }
2167    }
2168
2169    unsafe impl fidl::encoding::TypeMarker for ControlRemoveAddressRequest {
2170        type Owned = Self;
2171
2172        #[inline(always)]
2173        fn inline_align(_context: fidl::encoding::Context) -> usize {
2174            8
2175        }
2176
2177        #[inline(always)]
2178        fn inline_size(_context: fidl::encoding::Context) -> usize {
2179            24
2180        }
2181    }
2182
2183    unsafe impl<D: fidl::encoding::ResourceDialect>
2184        fidl::encoding::Encode<ControlRemoveAddressRequest, D> for &ControlRemoveAddressRequest
2185    {
2186        #[inline]
2187        unsafe fn encode(
2188            self,
2189            encoder: &mut fidl::encoding::Encoder<'_, D>,
2190            offset: usize,
2191            _depth: fidl::encoding::Depth,
2192        ) -> fidl::Result<()> {
2193            encoder.debug_check_bounds::<ControlRemoveAddressRequest>(offset);
2194            // Delegate to tuple encoding.
2195            fidl::encoding::Encode::<ControlRemoveAddressRequest, D>::encode(
2196                (<fidl_fuchsia_net__common::Subnet as fidl::encoding::ValueTypeMarker>::borrow(
2197                    &self.address,
2198                ),),
2199                encoder,
2200                offset,
2201                _depth,
2202            )
2203        }
2204    }
2205    unsafe impl<
2206            D: fidl::encoding::ResourceDialect,
2207            T0: fidl::encoding::Encode<fidl_fuchsia_net__common::Subnet, D>,
2208        > fidl::encoding::Encode<ControlRemoveAddressRequest, D> for (T0,)
2209    {
2210        #[inline]
2211        unsafe fn encode(
2212            self,
2213            encoder: &mut fidl::encoding::Encoder<'_, D>,
2214            offset: usize,
2215            depth: fidl::encoding::Depth,
2216        ) -> fidl::Result<()> {
2217            encoder.debug_check_bounds::<ControlRemoveAddressRequest>(offset);
2218            // Zero out padding regions. There's no need to apply masks
2219            // because the unmasked parts will be overwritten by fields.
2220            // Write the fields.
2221            self.0.encode(encoder, offset + 0, depth)?;
2222            Ok(())
2223        }
2224    }
2225
2226    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2227        for ControlRemoveAddressRequest
2228    {
2229        #[inline(always)]
2230        fn new_empty() -> Self {
2231            Self { address: fidl::new_empty!(fidl_fuchsia_net__common::Subnet, D) }
2232        }
2233
2234        #[inline]
2235        unsafe fn decode(
2236            &mut self,
2237            decoder: &mut fidl::encoding::Decoder<'_, D>,
2238            offset: usize,
2239            _depth: fidl::encoding::Depth,
2240        ) -> fidl::Result<()> {
2241            decoder.debug_check_bounds::<Self>(offset);
2242            // Verify that padding bytes are zero.
2243            fidl::decode!(
2244                fidl_fuchsia_net__common::Subnet,
2245                D,
2246                &mut self.address,
2247                decoder,
2248                offset + 0,
2249                _depth
2250            )?;
2251            Ok(())
2252        }
2253    }
2254
2255    impl fidl::encoding::ValueTypeMarker for ControlSetConfigurationRequest {
2256        type Borrowed<'a> = &'a Self;
2257        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2258            value
2259        }
2260    }
2261
2262    unsafe impl fidl::encoding::TypeMarker for ControlSetConfigurationRequest {
2263        type Owned = Self;
2264
2265        #[inline(always)]
2266        fn inline_align(_context: fidl::encoding::Context) -> usize {
2267            8
2268        }
2269
2270        #[inline(always)]
2271        fn inline_size(_context: fidl::encoding::Context) -> usize {
2272            16
2273        }
2274    }
2275
2276    unsafe impl<D: fidl::encoding::ResourceDialect>
2277        fidl::encoding::Encode<ControlSetConfigurationRequest, D>
2278        for &ControlSetConfigurationRequest
2279    {
2280        #[inline]
2281        unsafe fn encode(
2282            self,
2283            encoder: &mut fidl::encoding::Encoder<'_, D>,
2284            offset: usize,
2285            _depth: fidl::encoding::Depth,
2286        ) -> fidl::Result<()> {
2287            encoder.debug_check_bounds::<ControlSetConfigurationRequest>(offset);
2288            // Delegate to tuple encoding.
2289            fidl::encoding::Encode::<ControlSetConfigurationRequest, D>::encode(
2290                (<Configuration as fidl::encoding::ValueTypeMarker>::borrow(&self.config),),
2291                encoder,
2292                offset,
2293                _depth,
2294            )
2295        }
2296    }
2297    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Configuration, D>>
2298        fidl::encoding::Encode<ControlSetConfigurationRequest, D> for (T0,)
2299    {
2300        #[inline]
2301        unsafe fn encode(
2302            self,
2303            encoder: &mut fidl::encoding::Encoder<'_, D>,
2304            offset: usize,
2305            depth: fidl::encoding::Depth,
2306        ) -> fidl::Result<()> {
2307            encoder.debug_check_bounds::<ControlSetConfigurationRequest>(offset);
2308            // Zero out padding regions. There's no need to apply masks
2309            // because the unmasked parts will be overwritten by fields.
2310            // Write the fields.
2311            self.0.encode(encoder, offset + 0, depth)?;
2312            Ok(())
2313        }
2314    }
2315
2316    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2317        for ControlSetConfigurationRequest
2318    {
2319        #[inline(always)]
2320        fn new_empty() -> Self {
2321            Self { config: fidl::new_empty!(Configuration, D) }
2322        }
2323
2324        #[inline]
2325        unsafe fn decode(
2326            &mut self,
2327            decoder: &mut fidl::encoding::Decoder<'_, D>,
2328            offset: usize,
2329            _depth: fidl::encoding::Depth,
2330        ) -> fidl::Result<()> {
2331            decoder.debug_check_bounds::<Self>(offset);
2332            // Verify that padding bytes are zero.
2333            fidl::decode!(Configuration, D, &mut self.config, decoder, offset + 0, _depth)?;
2334            Ok(())
2335        }
2336    }
2337
2338    impl fidl::encoding::ValueTypeMarker for ControlDisableResponse {
2339        type Borrowed<'a> = &'a Self;
2340        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2341            value
2342        }
2343    }
2344
2345    unsafe impl fidl::encoding::TypeMarker for ControlDisableResponse {
2346        type Owned = Self;
2347
2348        #[inline(always)]
2349        fn inline_align(_context: fidl::encoding::Context) -> usize {
2350            1
2351        }
2352
2353        #[inline(always)]
2354        fn inline_size(_context: fidl::encoding::Context) -> usize {
2355            1
2356        }
2357    }
2358
2359    unsafe impl<D: fidl::encoding::ResourceDialect>
2360        fidl::encoding::Encode<ControlDisableResponse, D> for &ControlDisableResponse
2361    {
2362        #[inline]
2363        unsafe fn encode(
2364            self,
2365            encoder: &mut fidl::encoding::Encoder<'_, D>,
2366            offset: usize,
2367            _depth: fidl::encoding::Depth,
2368        ) -> fidl::Result<()> {
2369            encoder.debug_check_bounds::<ControlDisableResponse>(offset);
2370            // Delegate to tuple encoding.
2371            fidl::encoding::Encode::<ControlDisableResponse, D>::encode(
2372                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.did_disable),),
2373                encoder,
2374                offset,
2375                _depth,
2376            )
2377        }
2378    }
2379    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
2380        fidl::encoding::Encode<ControlDisableResponse, D> for (T0,)
2381    {
2382        #[inline]
2383        unsafe fn encode(
2384            self,
2385            encoder: &mut fidl::encoding::Encoder<'_, D>,
2386            offset: usize,
2387            depth: fidl::encoding::Depth,
2388        ) -> fidl::Result<()> {
2389            encoder.debug_check_bounds::<ControlDisableResponse>(offset);
2390            // Zero out padding regions. There's no need to apply masks
2391            // because the unmasked parts will be overwritten by fields.
2392            // Write the fields.
2393            self.0.encode(encoder, offset + 0, depth)?;
2394            Ok(())
2395        }
2396    }
2397
2398    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2399        for ControlDisableResponse
2400    {
2401        #[inline(always)]
2402        fn new_empty() -> Self {
2403            Self { did_disable: fidl::new_empty!(bool, D) }
2404        }
2405
2406        #[inline]
2407        unsafe fn decode(
2408            &mut self,
2409            decoder: &mut fidl::encoding::Decoder<'_, D>,
2410            offset: usize,
2411            _depth: fidl::encoding::Depth,
2412        ) -> fidl::Result<()> {
2413            decoder.debug_check_bounds::<Self>(offset);
2414            // Verify that padding bytes are zero.
2415            fidl::decode!(bool, D, &mut self.did_disable, decoder, offset + 0, _depth)?;
2416            Ok(())
2417        }
2418    }
2419
2420    impl fidl::encoding::ValueTypeMarker for ControlEnableResponse {
2421        type Borrowed<'a> = &'a Self;
2422        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2423            value
2424        }
2425    }
2426
2427    unsafe impl fidl::encoding::TypeMarker for ControlEnableResponse {
2428        type Owned = Self;
2429
2430        #[inline(always)]
2431        fn inline_align(_context: fidl::encoding::Context) -> usize {
2432            1
2433        }
2434
2435        #[inline(always)]
2436        fn inline_size(_context: fidl::encoding::Context) -> usize {
2437            1
2438        }
2439    }
2440
2441    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ControlEnableResponse, D>
2442        for &ControlEnableResponse
2443    {
2444        #[inline]
2445        unsafe fn encode(
2446            self,
2447            encoder: &mut fidl::encoding::Encoder<'_, D>,
2448            offset: usize,
2449            _depth: fidl::encoding::Depth,
2450        ) -> fidl::Result<()> {
2451            encoder.debug_check_bounds::<ControlEnableResponse>(offset);
2452            // Delegate to tuple encoding.
2453            fidl::encoding::Encode::<ControlEnableResponse, D>::encode(
2454                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.did_enable),),
2455                encoder,
2456                offset,
2457                _depth,
2458            )
2459        }
2460    }
2461    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
2462        fidl::encoding::Encode<ControlEnableResponse, D> for (T0,)
2463    {
2464        #[inline]
2465        unsafe fn encode(
2466            self,
2467            encoder: &mut fidl::encoding::Encoder<'_, D>,
2468            offset: usize,
2469            depth: fidl::encoding::Depth,
2470        ) -> fidl::Result<()> {
2471            encoder.debug_check_bounds::<ControlEnableResponse>(offset);
2472            // Zero out padding regions. There's no need to apply masks
2473            // because the unmasked parts will be overwritten by fields.
2474            // Write the fields.
2475            self.0.encode(encoder, offset + 0, depth)?;
2476            Ok(())
2477        }
2478    }
2479
2480    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ControlEnableResponse {
2481        #[inline(always)]
2482        fn new_empty() -> Self {
2483            Self { did_enable: fidl::new_empty!(bool, D) }
2484        }
2485
2486        #[inline]
2487        unsafe fn decode(
2488            &mut self,
2489            decoder: &mut fidl::encoding::Decoder<'_, D>,
2490            offset: usize,
2491            _depth: fidl::encoding::Depth,
2492        ) -> fidl::Result<()> {
2493            decoder.debug_check_bounds::<Self>(offset);
2494            // Verify that padding bytes are zero.
2495            fidl::decode!(bool, D, &mut self.did_enable, decoder, offset + 0, _depth)?;
2496            Ok(())
2497        }
2498    }
2499
2500    impl fidl::encoding::ValueTypeMarker for ControlGetConfigurationResponse {
2501        type Borrowed<'a> = &'a Self;
2502        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2503            value
2504        }
2505    }
2506
2507    unsafe impl fidl::encoding::TypeMarker for ControlGetConfigurationResponse {
2508        type Owned = Self;
2509
2510        #[inline(always)]
2511        fn inline_align(_context: fidl::encoding::Context) -> usize {
2512            8
2513        }
2514
2515        #[inline(always)]
2516        fn inline_size(_context: fidl::encoding::Context) -> usize {
2517            16
2518        }
2519    }
2520
2521    unsafe impl<D: fidl::encoding::ResourceDialect>
2522        fidl::encoding::Encode<ControlGetConfigurationResponse, D>
2523        for &ControlGetConfigurationResponse
2524    {
2525        #[inline]
2526        unsafe fn encode(
2527            self,
2528            encoder: &mut fidl::encoding::Encoder<'_, D>,
2529            offset: usize,
2530            _depth: fidl::encoding::Depth,
2531        ) -> fidl::Result<()> {
2532            encoder.debug_check_bounds::<ControlGetConfigurationResponse>(offset);
2533            // Delegate to tuple encoding.
2534            fidl::encoding::Encode::<ControlGetConfigurationResponse, D>::encode(
2535                (<Configuration as fidl::encoding::ValueTypeMarker>::borrow(&self.config),),
2536                encoder,
2537                offset,
2538                _depth,
2539            )
2540        }
2541    }
2542    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Configuration, D>>
2543        fidl::encoding::Encode<ControlGetConfigurationResponse, D> for (T0,)
2544    {
2545        #[inline]
2546        unsafe fn encode(
2547            self,
2548            encoder: &mut fidl::encoding::Encoder<'_, D>,
2549            offset: usize,
2550            depth: fidl::encoding::Depth,
2551        ) -> fidl::Result<()> {
2552            encoder.debug_check_bounds::<ControlGetConfigurationResponse>(offset);
2553            // Zero out padding regions. There's no need to apply masks
2554            // because the unmasked parts will be overwritten by fields.
2555            // Write the fields.
2556            self.0.encode(encoder, offset + 0, depth)?;
2557            Ok(())
2558        }
2559    }
2560
2561    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2562        for ControlGetConfigurationResponse
2563    {
2564        #[inline(always)]
2565        fn new_empty() -> Self {
2566            Self { config: fidl::new_empty!(Configuration, D) }
2567        }
2568
2569        #[inline]
2570        unsafe fn decode(
2571            &mut self,
2572            decoder: &mut fidl::encoding::Decoder<'_, D>,
2573            offset: usize,
2574            _depth: fidl::encoding::Depth,
2575        ) -> fidl::Result<()> {
2576            decoder.debug_check_bounds::<Self>(offset);
2577            // Verify that padding bytes are zero.
2578            fidl::decode!(Configuration, D, &mut self.config, decoder, offset + 0, _depth)?;
2579            Ok(())
2580        }
2581    }
2582
2583    impl fidl::encoding::ValueTypeMarker for ControlRemoveAddressResponse {
2584        type Borrowed<'a> = &'a Self;
2585        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2586            value
2587        }
2588    }
2589
2590    unsafe impl fidl::encoding::TypeMarker for ControlRemoveAddressResponse {
2591        type Owned = Self;
2592
2593        #[inline(always)]
2594        fn inline_align(_context: fidl::encoding::Context) -> usize {
2595            1
2596        }
2597
2598        #[inline(always)]
2599        fn inline_size(_context: fidl::encoding::Context) -> usize {
2600            1
2601        }
2602    }
2603
2604    unsafe impl<D: fidl::encoding::ResourceDialect>
2605        fidl::encoding::Encode<ControlRemoveAddressResponse, D> for &ControlRemoveAddressResponse
2606    {
2607        #[inline]
2608        unsafe fn encode(
2609            self,
2610            encoder: &mut fidl::encoding::Encoder<'_, D>,
2611            offset: usize,
2612            _depth: fidl::encoding::Depth,
2613        ) -> fidl::Result<()> {
2614            encoder.debug_check_bounds::<ControlRemoveAddressResponse>(offset);
2615            // Delegate to tuple encoding.
2616            fidl::encoding::Encode::<ControlRemoveAddressResponse, D>::encode(
2617                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.did_remove),),
2618                encoder,
2619                offset,
2620                _depth,
2621            )
2622        }
2623    }
2624    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
2625        fidl::encoding::Encode<ControlRemoveAddressResponse, D> for (T0,)
2626    {
2627        #[inline]
2628        unsafe fn encode(
2629            self,
2630            encoder: &mut fidl::encoding::Encoder<'_, D>,
2631            offset: usize,
2632            depth: fidl::encoding::Depth,
2633        ) -> fidl::Result<()> {
2634            encoder.debug_check_bounds::<ControlRemoveAddressResponse>(offset);
2635            // Zero out padding regions. There's no need to apply masks
2636            // because the unmasked parts will be overwritten by fields.
2637            // Write the fields.
2638            self.0.encode(encoder, offset + 0, depth)?;
2639            Ok(())
2640        }
2641    }
2642
2643    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2644        for ControlRemoveAddressResponse
2645    {
2646        #[inline(always)]
2647        fn new_empty() -> Self {
2648            Self { did_remove: fidl::new_empty!(bool, D) }
2649        }
2650
2651        #[inline]
2652        unsafe fn decode(
2653            &mut self,
2654            decoder: &mut fidl::encoding::Decoder<'_, D>,
2655            offset: usize,
2656            _depth: fidl::encoding::Depth,
2657        ) -> fidl::Result<()> {
2658            decoder.debug_check_bounds::<Self>(offset);
2659            // Verify that padding bytes are zero.
2660            fidl::decode!(bool, D, &mut self.did_remove, decoder, offset + 0, _depth)?;
2661            Ok(())
2662        }
2663    }
2664
2665    impl fidl::encoding::ValueTypeMarker for ControlSetConfigurationResponse {
2666        type Borrowed<'a> = &'a Self;
2667        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2668            value
2669        }
2670    }
2671
2672    unsafe impl fidl::encoding::TypeMarker for ControlSetConfigurationResponse {
2673        type Owned = Self;
2674
2675        #[inline(always)]
2676        fn inline_align(_context: fidl::encoding::Context) -> usize {
2677            8
2678        }
2679
2680        #[inline(always)]
2681        fn inline_size(_context: fidl::encoding::Context) -> usize {
2682            16
2683        }
2684    }
2685
2686    unsafe impl<D: fidl::encoding::ResourceDialect>
2687        fidl::encoding::Encode<ControlSetConfigurationResponse, D>
2688        for &ControlSetConfigurationResponse
2689    {
2690        #[inline]
2691        unsafe fn encode(
2692            self,
2693            encoder: &mut fidl::encoding::Encoder<'_, D>,
2694            offset: usize,
2695            _depth: fidl::encoding::Depth,
2696        ) -> fidl::Result<()> {
2697            encoder.debug_check_bounds::<ControlSetConfigurationResponse>(offset);
2698            // Delegate to tuple encoding.
2699            fidl::encoding::Encode::<ControlSetConfigurationResponse, D>::encode(
2700                (<Configuration as fidl::encoding::ValueTypeMarker>::borrow(&self.previous_config),),
2701                encoder,
2702                offset,
2703                _depth,
2704            )
2705        }
2706    }
2707    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Configuration, D>>
2708        fidl::encoding::Encode<ControlSetConfigurationResponse, D> for (T0,)
2709    {
2710        #[inline]
2711        unsafe fn encode(
2712            self,
2713            encoder: &mut fidl::encoding::Encoder<'_, D>,
2714            offset: usize,
2715            depth: fidl::encoding::Depth,
2716        ) -> fidl::Result<()> {
2717            encoder.debug_check_bounds::<ControlSetConfigurationResponse>(offset);
2718            // Zero out padding regions. There's no need to apply masks
2719            // because the unmasked parts will be overwritten by fields.
2720            // Write the fields.
2721            self.0.encode(encoder, offset + 0, depth)?;
2722            Ok(())
2723        }
2724    }
2725
2726    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2727        for ControlSetConfigurationResponse
2728    {
2729        #[inline(always)]
2730        fn new_empty() -> Self {
2731            Self { previous_config: fidl::new_empty!(Configuration, D) }
2732        }
2733
2734        #[inline]
2735        unsafe fn decode(
2736            &mut self,
2737            decoder: &mut fidl::encoding::Decoder<'_, D>,
2738            offset: usize,
2739            _depth: fidl::encoding::Depth,
2740        ) -> fidl::Result<()> {
2741            decoder.debug_check_bounds::<Self>(offset);
2742            // Verify that padding bytes are zero.
2743            fidl::decode!(
2744                Configuration,
2745                D,
2746                &mut self.previous_config,
2747                decoder,
2748                offset + 0,
2749                _depth
2750            )?;
2751            Ok(())
2752        }
2753    }
2754
2755    impl fidl::encoding::ValueTypeMarker for Empty {
2756        type Borrowed<'a> = &'a Self;
2757        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2758            value
2759        }
2760    }
2761
2762    unsafe impl fidl::encoding::TypeMarker for Empty {
2763        type Owned = Self;
2764
2765        #[inline(always)]
2766        fn inline_align(_context: fidl::encoding::Context) -> usize {
2767            1
2768        }
2769
2770        #[inline(always)]
2771        fn inline_size(_context: fidl::encoding::Context) -> usize {
2772            1
2773        }
2774    }
2775
2776    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Empty, D> for &Empty {
2777        #[inline]
2778        unsafe fn encode(
2779            self,
2780            encoder: &mut fidl::encoding::Encoder<'_, D>,
2781            offset: usize,
2782            _depth: fidl::encoding::Depth,
2783        ) -> fidl::Result<()> {
2784            encoder.debug_check_bounds::<Empty>(offset);
2785            encoder.write_num(0u8, offset);
2786            Ok(())
2787        }
2788    }
2789
2790    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Empty {
2791        #[inline(always)]
2792        fn new_empty() -> Self {
2793            Self
2794        }
2795
2796        #[inline]
2797        unsafe fn decode(
2798            &mut self,
2799            decoder: &mut fidl::encoding::Decoder<'_, D>,
2800            offset: usize,
2801            _depth: fidl::encoding::Depth,
2802        ) -> fidl::Result<()> {
2803            decoder.debug_check_bounds::<Self>(offset);
2804            match decoder.read_num::<u8>(offset) {
2805                0 => Ok(()),
2806                _ => Err(fidl::Error::Invalid),
2807            }
2808        }
2809    }
2810
2811    impl AddressParameters {
2812        #[inline(always)]
2813        fn max_ordinal_present(&self) -> u64 {
2814            if let Some(_) = self.perform_dad {
2815                return 4;
2816            }
2817            if let Some(_) = self.add_subnet_route {
2818                return 3;
2819            }
2820            if let Some(_) = self.temporary {
2821                return 2;
2822            }
2823            if let Some(_) = self.initial_properties {
2824                return 1;
2825            }
2826            0
2827        }
2828    }
2829
2830    impl fidl::encoding::ValueTypeMarker for AddressParameters {
2831        type Borrowed<'a> = &'a Self;
2832        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2833            value
2834        }
2835    }
2836
2837    unsafe impl fidl::encoding::TypeMarker for AddressParameters {
2838        type Owned = Self;
2839
2840        #[inline(always)]
2841        fn inline_align(_context: fidl::encoding::Context) -> usize {
2842            8
2843        }
2844
2845        #[inline(always)]
2846        fn inline_size(_context: fidl::encoding::Context) -> usize {
2847            16
2848        }
2849    }
2850
2851    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AddressParameters, D>
2852        for &AddressParameters
2853    {
2854        unsafe fn encode(
2855            self,
2856            encoder: &mut fidl::encoding::Encoder<'_, D>,
2857            offset: usize,
2858            mut depth: fidl::encoding::Depth,
2859        ) -> fidl::Result<()> {
2860            encoder.debug_check_bounds::<AddressParameters>(offset);
2861            // Vector header
2862            let max_ordinal: u64 = self.max_ordinal_present();
2863            encoder.write_num(max_ordinal, offset);
2864            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2865            // Calling encoder.out_of_line_offset(0) is not allowed.
2866            if max_ordinal == 0 {
2867                return Ok(());
2868            }
2869            depth.increment()?;
2870            let envelope_size = 8;
2871            let bytes_len = max_ordinal as usize * envelope_size;
2872            #[allow(unused_variables)]
2873            let offset = encoder.out_of_line_offset(bytes_len);
2874            let mut _prev_end_offset: usize = 0;
2875            if 1 > max_ordinal {
2876                return Ok(());
2877            }
2878
2879            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2880            // are envelope_size bytes.
2881            let cur_offset: usize = (1 - 1) * envelope_size;
2882
2883            // Zero reserved fields.
2884            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2885
2886            // Safety:
2887            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2888            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2889            //   envelope_size bytes, there is always sufficient room.
2890            fidl::encoding::encode_in_envelope_optional::<AddressProperties, D>(
2891                self.initial_properties
2892                    .as_ref()
2893                    .map(<AddressProperties as fidl::encoding::ValueTypeMarker>::borrow),
2894                encoder,
2895                offset + cur_offset,
2896                depth,
2897            )?;
2898
2899            _prev_end_offset = cur_offset + envelope_size;
2900            if 2 > max_ordinal {
2901                return Ok(());
2902            }
2903
2904            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2905            // are envelope_size bytes.
2906            let cur_offset: usize = (2 - 1) * envelope_size;
2907
2908            // Zero reserved fields.
2909            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2910
2911            // Safety:
2912            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2913            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2914            //   envelope_size bytes, there is always sufficient room.
2915            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2916                self.temporary.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2917                encoder,
2918                offset + cur_offset,
2919                depth,
2920            )?;
2921
2922            _prev_end_offset = cur_offset + envelope_size;
2923            if 3 > max_ordinal {
2924                return Ok(());
2925            }
2926
2927            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2928            // are envelope_size bytes.
2929            let cur_offset: usize = (3 - 1) * envelope_size;
2930
2931            // Zero reserved fields.
2932            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2933
2934            // Safety:
2935            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2936            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2937            //   envelope_size bytes, there is always sufficient room.
2938            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2939                self.add_subnet_route
2940                    .as_ref()
2941                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2942                encoder,
2943                offset + cur_offset,
2944                depth,
2945            )?;
2946
2947            _prev_end_offset = cur_offset + envelope_size;
2948            if 4 > max_ordinal {
2949                return Ok(());
2950            }
2951
2952            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2953            // are envelope_size bytes.
2954            let cur_offset: usize = (4 - 1) * envelope_size;
2955
2956            // Zero reserved fields.
2957            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2958
2959            // Safety:
2960            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2961            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2962            //   envelope_size bytes, there is always sufficient room.
2963            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2964                self.perform_dad.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2965                encoder,
2966                offset + cur_offset,
2967                depth,
2968            )?;
2969
2970            _prev_end_offset = cur_offset + envelope_size;
2971
2972            Ok(())
2973        }
2974    }
2975
2976    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AddressParameters {
2977        #[inline(always)]
2978        fn new_empty() -> Self {
2979            Self::default()
2980        }
2981
2982        unsafe fn decode(
2983            &mut self,
2984            decoder: &mut fidl::encoding::Decoder<'_, D>,
2985            offset: usize,
2986            mut depth: fidl::encoding::Depth,
2987        ) -> fidl::Result<()> {
2988            decoder.debug_check_bounds::<Self>(offset);
2989            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2990                None => return Err(fidl::Error::NotNullable),
2991                Some(len) => len,
2992            };
2993            // Calling decoder.out_of_line_offset(0) is not allowed.
2994            if len == 0 {
2995                return Ok(());
2996            };
2997            depth.increment()?;
2998            let envelope_size = 8;
2999            let bytes_len = len * envelope_size;
3000            let offset = decoder.out_of_line_offset(bytes_len)?;
3001            // Decode the envelope for each type.
3002            let mut _next_ordinal_to_read = 0;
3003            let mut next_offset = offset;
3004            let end_offset = offset + bytes_len;
3005            _next_ordinal_to_read += 1;
3006            if next_offset >= end_offset {
3007                return Ok(());
3008            }
3009
3010            // Decode unknown envelopes for gaps in ordinals.
3011            while _next_ordinal_to_read < 1 {
3012                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3013                _next_ordinal_to_read += 1;
3014                next_offset += envelope_size;
3015            }
3016
3017            let next_out_of_line = decoder.next_out_of_line();
3018            let handles_before = decoder.remaining_handles();
3019            if let Some((inlined, num_bytes, num_handles)) =
3020                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3021            {
3022                let member_inline_size =
3023                    <AddressProperties as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3024                if inlined != (member_inline_size <= 4) {
3025                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3026                }
3027                let inner_offset;
3028                let mut inner_depth = depth.clone();
3029                if inlined {
3030                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3031                    inner_offset = next_offset;
3032                } else {
3033                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3034                    inner_depth.increment()?;
3035                }
3036                let val_ref = self
3037                    .initial_properties
3038                    .get_or_insert_with(|| fidl::new_empty!(AddressProperties, D));
3039                fidl::decode!(AddressProperties, D, val_ref, decoder, inner_offset, inner_depth)?;
3040                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3041                {
3042                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3043                }
3044                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3045                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3046                }
3047            }
3048
3049            next_offset += envelope_size;
3050            _next_ordinal_to_read += 1;
3051            if next_offset >= end_offset {
3052                return Ok(());
3053            }
3054
3055            // Decode unknown envelopes for gaps in ordinals.
3056            while _next_ordinal_to_read < 2 {
3057                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3058                _next_ordinal_to_read += 1;
3059                next_offset += envelope_size;
3060            }
3061
3062            let next_out_of_line = decoder.next_out_of_line();
3063            let handles_before = decoder.remaining_handles();
3064            if let Some((inlined, num_bytes, num_handles)) =
3065                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3066            {
3067                let member_inline_size =
3068                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3069                if inlined != (member_inline_size <= 4) {
3070                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3071                }
3072                let inner_offset;
3073                let mut inner_depth = depth.clone();
3074                if inlined {
3075                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3076                    inner_offset = next_offset;
3077                } else {
3078                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3079                    inner_depth.increment()?;
3080                }
3081                let val_ref = self.temporary.get_or_insert_with(|| fidl::new_empty!(bool, D));
3082                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3083                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3084                {
3085                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3086                }
3087                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3088                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3089                }
3090            }
3091
3092            next_offset += envelope_size;
3093            _next_ordinal_to_read += 1;
3094            if next_offset >= end_offset {
3095                return Ok(());
3096            }
3097
3098            // Decode unknown envelopes for gaps in ordinals.
3099            while _next_ordinal_to_read < 3 {
3100                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3101                _next_ordinal_to_read += 1;
3102                next_offset += envelope_size;
3103            }
3104
3105            let next_out_of_line = decoder.next_out_of_line();
3106            let handles_before = decoder.remaining_handles();
3107            if let Some((inlined, num_bytes, num_handles)) =
3108                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3109            {
3110                let member_inline_size =
3111                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3112                if inlined != (member_inline_size <= 4) {
3113                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3114                }
3115                let inner_offset;
3116                let mut inner_depth = depth.clone();
3117                if inlined {
3118                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3119                    inner_offset = next_offset;
3120                } else {
3121                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3122                    inner_depth.increment()?;
3123                }
3124                let val_ref =
3125                    self.add_subnet_route.get_or_insert_with(|| fidl::new_empty!(bool, D));
3126                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3127                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3128                {
3129                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3130                }
3131                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3132                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3133                }
3134            }
3135
3136            next_offset += envelope_size;
3137            _next_ordinal_to_read += 1;
3138            if next_offset >= end_offset {
3139                return Ok(());
3140            }
3141
3142            // Decode unknown envelopes for gaps in ordinals.
3143            while _next_ordinal_to_read < 4 {
3144                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3145                _next_ordinal_to_read += 1;
3146                next_offset += envelope_size;
3147            }
3148
3149            let next_out_of_line = decoder.next_out_of_line();
3150            let handles_before = decoder.remaining_handles();
3151            if let Some((inlined, num_bytes, num_handles)) =
3152                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3153            {
3154                let member_inline_size =
3155                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3156                if inlined != (member_inline_size <= 4) {
3157                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3158                }
3159                let inner_offset;
3160                let mut inner_depth = depth.clone();
3161                if inlined {
3162                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3163                    inner_offset = next_offset;
3164                } else {
3165                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3166                    inner_depth.increment()?;
3167                }
3168                let val_ref = self.perform_dad.get_or_insert_with(|| fidl::new_empty!(bool, D));
3169                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3170                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3171                {
3172                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3173                }
3174                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3175                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3176                }
3177            }
3178
3179            next_offset += envelope_size;
3180
3181            // Decode the remaining unknown envelopes.
3182            while next_offset < end_offset {
3183                _next_ordinal_to_read += 1;
3184                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3185                next_offset += envelope_size;
3186            }
3187
3188            Ok(())
3189        }
3190    }
3191
3192    impl AddressProperties {
3193        #[inline(always)]
3194        fn max_ordinal_present(&self) -> u64 {
3195            if let Some(_) = self.valid_lifetime_end {
3196                return 2;
3197            }
3198            if let Some(_) = self.preferred_lifetime_info {
3199                return 1;
3200            }
3201            0
3202        }
3203    }
3204
3205    impl fidl::encoding::ValueTypeMarker for AddressProperties {
3206        type Borrowed<'a> = &'a Self;
3207        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3208            value
3209        }
3210    }
3211
3212    unsafe impl fidl::encoding::TypeMarker for AddressProperties {
3213        type Owned = Self;
3214
3215        #[inline(always)]
3216        fn inline_align(_context: fidl::encoding::Context) -> usize {
3217            8
3218        }
3219
3220        #[inline(always)]
3221        fn inline_size(_context: fidl::encoding::Context) -> usize {
3222            16
3223        }
3224    }
3225
3226    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AddressProperties, D>
3227        for &AddressProperties
3228    {
3229        unsafe fn encode(
3230            self,
3231            encoder: &mut fidl::encoding::Encoder<'_, D>,
3232            offset: usize,
3233            mut depth: fidl::encoding::Depth,
3234        ) -> fidl::Result<()> {
3235            encoder.debug_check_bounds::<AddressProperties>(offset);
3236            // Vector header
3237            let max_ordinal: u64 = self.max_ordinal_present();
3238            encoder.write_num(max_ordinal, offset);
3239            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3240            // Calling encoder.out_of_line_offset(0) is not allowed.
3241            if max_ordinal == 0 {
3242                return Ok(());
3243            }
3244            depth.increment()?;
3245            let envelope_size = 8;
3246            let bytes_len = max_ordinal as usize * envelope_size;
3247            #[allow(unused_variables)]
3248            let offset = encoder.out_of_line_offset(bytes_len);
3249            let mut _prev_end_offset: usize = 0;
3250            if 1 > max_ordinal {
3251                return Ok(());
3252            }
3253
3254            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3255            // are envelope_size bytes.
3256            let cur_offset: usize = (1 - 1) * envelope_size;
3257
3258            // Zero reserved fields.
3259            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3260
3261            // Safety:
3262            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3263            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3264            //   envelope_size bytes, there is always sufficient room.
3265            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net_interfaces__common::PreferredLifetimeInfo, D>(
3266            self.preferred_lifetime_info.as_ref().map(<fidl_fuchsia_net_interfaces__common::PreferredLifetimeInfo as fidl::encoding::ValueTypeMarker>::borrow),
3267            encoder, offset + cur_offset, depth
3268        )?;
3269
3270            _prev_end_offset = cur_offset + envelope_size;
3271            if 2 > max_ordinal {
3272                return Ok(());
3273            }
3274
3275            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3276            // are envelope_size bytes.
3277            let cur_offset: usize = (2 - 1) * envelope_size;
3278
3279            // Zero reserved fields.
3280            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3281
3282            // Safety:
3283            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3284            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3285            //   envelope_size bytes, there is always sufficient room.
3286            fidl::encoding::encode_in_envelope_optional::<i64, D>(
3287                self.valid_lifetime_end
3288                    .as_ref()
3289                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
3290                encoder,
3291                offset + cur_offset,
3292                depth,
3293            )?;
3294
3295            _prev_end_offset = cur_offset + envelope_size;
3296
3297            Ok(())
3298        }
3299    }
3300
3301    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AddressProperties {
3302        #[inline(always)]
3303        fn new_empty() -> Self {
3304            Self::default()
3305        }
3306
3307        unsafe fn decode(
3308            &mut self,
3309            decoder: &mut fidl::encoding::Decoder<'_, D>,
3310            offset: usize,
3311            mut depth: fidl::encoding::Depth,
3312        ) -> fidl::Result<()> {
3313            decoder.debug_check_bounds::<Self>(offset);
3314            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3315                None => return Err(fidl::Error::NotNullable),
3316                Some(len) => len,
3317            };
3318            // Calling decoder.out_of_line_offset(0) is not allowed.
3319            if len == 0 {
3320                return Ok(());
3321            };
3322            depth.increment()?;
3323            let envelope_size = 8;
3324            let bytes_len = len * envelope_size;
3325            let offset = decoder.out_of_line_offset(bytes_len)?;
3326            // Decode the envelope for each type.
3327            let mut _next_ordinal_to_read = 0;
3328            let mut next_offset = offset;
3329            let end_offset = offset + bytes_len;
3330            _next_ordinal_to_read += 1;
3331            if next_offset >= end_offset {
3332                return Ok(());
3333            }
3334
3335            // Decode unknown envelopes for gaps in ordinals.
3336            while _next_ordinal_to_read < 1 {
3337                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3338                _next_ordinal_to_read += 1;
3339                next_offset += envelope_size;
3340            }
3341
3342            let next_out_of_line = decoder.next_out_of_line();
3343            let handles_before = decoder.remaining_handles();
3344            if let Some((inlined, num_bytes, num_handles)) =
3345                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3346            {
3347                let member_inline_size = <fidl_fuchsia_net_interfaces__common::PreferredLifetimeInfo as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3348                if inlined != (member_inline_size <= 4) {
3349                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3350                }
3351                let inner_offset;
3352                let mut inner_depth = depth.clone();
3353                if inlined {
3354                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3355                    inner_offset = next_offset;
3356                } else {
3357                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3358                    inner_depth.increment()?;
3359                }
3360                let val_ref = self.preferred_lifetime_info.get_or_insert_with(|| {
3361                    fidl::new_empty!(fidl_fuchsia_net_interfaces__common::PreferredLifetimeInfo, D)
3362                });
3363                fidl::decode!(
3364                    fidl_fuchsia_net_interfaces__common::PreferredLifetimeInfo,
3365                    D,
3366                    val_ref,
3367                    decoder,
3368                    inner_offset,
3369                    inner_depth
3370                )?;
3371                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3372                {
3373                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3374                }
3375                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3376                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3377                }
3378            }
3379
3380            next_offset += envelope_size;
3381            _next_ordinal_to_read += 1;
3382            if next_offset >= end_offset {
3383                return Ok(());
3384            }
3385
3386            // Decode unknown envelopes for gaps in ordinals.
3387            while _next_ordinal_to_read < 2 {
3388                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3389                _next_ordinal_to_read += 1;
3390                next_offset += envelope_size;
3391            }
3392
3393            let next_out_of_line = decoder.next_out_of_line();
3394            let handles_before = decoder.remaining_handles();
3395            if let Some((inlined, num_bytes, num_handles)) =
3396                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3397            {
3398                let member_inline_size =
3399                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3400                if inlined != (member_inline_size <= 4) {
3401                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3402                }
3403                let inner_offset;
3404                let mut inner_depth = depth.clone();
3405                if inlined {
3406                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3407                    inner_offset = next_offset;
3408                } else {
3409                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3410                    inner_depth.increment()?;
3411                }
3412                let val_ref =
3413                    self.valid_lifetime_end.get_or_insert_with(|| fidl::new_empty!(i64, D));
3414                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
3415                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3416                {
3417                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3418                }
3419                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3420                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3421                }
3422            }
3423
3424            next_offset += envelope_size;
3425
3426            // Decode the remaining unknown envelopes.
3427            while next_offset < end_offset {
3428                _next_ordinal_to_read += 1;
3429                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3430                next_offset += envelope_size;
3431            }
3432
3433            Ok(())
3434        }
3435    }
3436
3437    impl ArpConfiguration {
3438        #[inline(always)]
3439        fn max_ordinal_present(&self) -> u64 {
3440            if let Some(_) = self.dad {
3441                return 2;
3442            }
3443            if let Some(_) = self.nud {
3444                return 1;
3445            }
3446            0
3447        }
3448    }
3449
3450    impl fidl::encoding::ValueTypeMarker for ArpConfiguration {
3451        type Borrowed<'a> = &'a Self;
3452        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3453            value
3454        }
3455    }
3456
3457    unsafe impl fidl::encoding::TypeMarker for ArpConfiguration {
3458        type Owned = Self;
3459
3460        #[inline(always)]
3461        fn inline_align(_context: fidl::encoding::Context) -> usize {
3462            8
3463        }
3464
3465        #[inline(always)]
3466        fn inline_size(_context: fidl::encoding::Context) -> usize {
3467            16
3468        }
3469    }
3470
3471    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ArpConfiguration, D>
3472        for &ArpConfiguration
3473    {
3474        unsafe fn encode(
3475            self,
3476            encoder: &mut fidl::encoding::Encoder<'_, D>,
3477            offset: usize,
3478            mut depth: fidl::encoding::Depth,
3479        ) -> fidl::Result<()> {
3480            encoder.debug_check_bounds::<ArpConfiguration>(offset);
3481            // Vector header
3482            let max_ordinal: u64 = self.max_ordinal_present();
3483            encoder.write_num(max_ordinal, offset);
3484            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3485            // Calling encoder.out_of_line_offset(0) is not allowed.
3486            if max_ordinal == 0 {
3487                return Ok(());
3488            }
3489            depth.increment()?;
3490            let envelope_size = 8;
3491            let bytes_len = max_ordinal as usize * envelope_size;
3492            #[allow(unused_variables)]
3493            let offset = encoder.out_of_line_offset(bytes_len);
3494            let mut _prev_end_offset: usize = 0;
3495            if 1 > max_ordinal {
3496                return Ok(());
3497            }
3498
3499            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3500            // are envelope_size bytes.
3501            let cur_offset: usize = (1 - 1) * envelope_size;
3502
3503            // Zero reserved fields.
3504            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3505
3506            // Safety:
3507            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3508            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3509            //   envelope_size bytes, there is always sufficient room.
3510            fidl::encoding::encode_in_envelope_optional::<NudConfiguration, D>(
3511                self.nud
3512                    .as_ref()
3513                    .map(<NudConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
3514                encoder,
3515                offset + cur_offset,
3516                depth,
3517            )?;
3518
3519            _prev_end_offset = cur_offset + envelope_size;
3520            if 2 > max_ordinal {
3521                return Ok(());
3522            }
3523
3524            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3525            // are envelope_size bytes.
3526            let cur_offset: usize = (2 - 1) * envelope_size;
3527
3528            // Zero reserved fields.
3529            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3530
3531            // Safety:
3532            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3533            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3534            //   envelope_size bytes, there is always sufficient room.
3535            fidl::encoding::encode_in_envelope_optional::<DadConfiguration, D>(
3536                self.dad
3537                    .as_ref()
3538                    .map(<DadConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
3539                encoder,
3540                offset + cur_offset,
3541                depth,
3542            )?;
3543
3544            _prev_end_offset = cur_offset + envelope_size;
3545
3546            Ok(())
3547        }
3548    }
3549
3550    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ArpConfiguration {
3551        #[inline(always)]
3552        fn new_empty() -> Self {
3553            Self::default()
3554        }
3555
3556        unsafe fn decode(
3557            &mut self,
3558            decoder: &mut fidl::encoding::Decoder<'_, D>,
3559            offset: usize,
3560            mut depth: fidl::encoding::Depth,
3561        ) -> fidl::Result<()> {
3562            decoder.debug_check_bounds::<Self>(offset);
3563            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3564                None => return Err(fidl::Error::NotNullable),
3565                Some(len) => len,
3566            };
3567            // Calling decoder.out_of_line_offset(0) is not allowed.
3568            if len == 0 {
3569                return Ok(());
3570            };
3571            depth.increment()?;
3572            let envelope_size = 8;
3573            let bytes_len = len * envelope_size;
3574            let offset = decoder.out_of_line_offset(bytes_len)?;
3575            // Decode the envelope for each type.
3576            let mut _next_ordinal_to_read = 0;
3577            let mut next_offset = offset;
3578            let end_offset = offset + bytes_len;
3579            _next_ordinal_to_read += 1;
3580            if next_offset >= end_offset {
3581                return Ok(());
3582            }
3583
3584            // Decode unknown envelopes for gaps in ordinals.
3585            while _next_ordinal_to_read < 1 {
3586                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3587                _next_ordinal_to_read += 1;
3588                next_offset += envelope_size;
3589            }
3590
3591            let next_out_of_line = decoder.next_out_of_line();
3592            let handles_before = decoder.remaining_handles();
3593            if let Some((inlined, num_bytes, num_handles)) =
3594                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3595            {
3596                let member_inline_size =
3597                    <NudConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3598                if inlined != (member_inline_size <= 4) {
3599                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3600                }
3601                let inner_offset;
3602                let mut inner_depth = depth.clone();
3603                if inlined {
3604                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3605                    inner_offset = next_offset;
3606                } else {
3607                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3608                    inner_depth.increment()?;
3609                }
3610                let val_ref = self.nud.get_or_insert_with(|| fidl::new_empty!(NudConfiguration, D));
3611                fidl::decode!(NudConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
3612                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3613                {
3614                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3615                }
3616                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3617                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3618                }
3619            }
3620
3621            next_offset += envelope_size;
3622            _next_ordinal_to_read += 1;
3623            if next_offset >= end_offset {
3624                return Ok(());
3625            }
3626
3627            // Decode unknown envelopes for gaps in ordinals.
3628            while _next_ordinal_to_read < 2 {
3629                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3630                _next_ordinal_to_read += 1;
3631                next_offset += envelope_size;
3632            }
3633
3634            let next_out_of_line = decoder.next_out_of_line();
3635            let handles_before = decoder.remaining_handles();
3636            if let Some((inlined, num_bytes, num_handles)) =
3637                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3638            {
3639                let member_inline_size =
3640                    <DadConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3641                if inlined != (member_inline_size <= 4) {
3642                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3643                }
3644                let inner_offset;
3645                let mut inner_depth = depth.clone();
3646                if inlined {
3647                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3648                    inner_offset = next_offset;
3649                } else {
3650                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3651                    inner_depth.increment()?;
3652                }
3653                let val_ref = self.dad.get_or_insert_with(|| fidl::new_empty!(DadConfiguration, D));
3654                fidl::decode!(DadConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
3655                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3656                {
3657                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3658                }
3659                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3660                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3661                }
3662            }
3663
3664            next_offset += envelope_size;
3665
3666            // Decode the remaining unknown envelopes.
3667            while next_offset < end_offset {
3668                _next_ordinal_to_read += 1;
3669                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3670                next_offset += envelope_size;
3671            }
3672
3673            Ok(())
3674        }
3675    }
3676
3677    impl Configuration {
3678        #[inline(always)]
3679        fn max_ordinal_present(&self) -> u64 {
3680            if let Some(_) = self.ipv6 {
3681                return 2;
3682            }
3683            if let Some(_) = self.ipv4 {
3684                return 1;
3685            }
3686            0
3687        }
3688    }
3689
3690    impl fidl::encoding::ValueTypeMarker for Configuration {
3691        type Borrowed<'a> = &'a Self;
3692        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3693            value
3694        }
3695    }
3696
3697    unsafe impl fidl::encoding::TypeMarker for Configuration {
3698        type Owned = Self;
3699
3700        #[inline(always)]
3701        fn inline_align(_context: fidl::encoding::Context) -> usize {
3702            8
3703        }
3704
3705        #[inline(always)]
3706        fn inline_size(_context: fidl::encoding::Context) -> usize {
3707            16
3708        }
3709    }
3710
3711    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Configuration, D>
3712        for &Configuration
3713    {
3714        unsafe fn encode(
3715            self,
3716            encoder: &mut fidl::encoding::Encoder<'_, D>,
3717            offset: usize,
3718            mut depth: fidl::encoding::Depth,
3719        ) -> fidl::Result<()> {
3720            encoder.debug_check_bounds::<Configuration>(offset);
3721            // Vector header
3722            let max_ordinal: u64 = self.max_ordinal_present();
3723            encoder.write_num(max_ordinal, offset);
3724            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3725            // Calling encoder.out_of_line_offset(0) is not allowed.
3726            if max_ordinal == 0 {
3727                return Ok(());
3728            }
3729            depth.increment()?;
3730            let envelope_size = 8;
3731            let bytes_len = max_ordinal as usize * envelope_size;
3732            #[allow(unused_variables)]
3733            let offset = encoder.out_of_line_offset(bytes_len);
3734            let mut _prev_end_offset: usize = 0;
3735            if 1 > max_ordinal {
3736                return Ok(());
3737            }
3738
3739            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3740            // are envelope_size bytes.
3741            let cur_offset: usize = (1 - 1) * envelope_size;
3742
3743            // Zero reserved fields.
3744            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3745
3746            // Safety:
3747            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3748            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3749            //   envelope_size bytes, there is always sufficient room.
3750            fidl::encoding::encode_in_envelope_optional::<Ipv4Configuration, D>(
3751                self.ipv4
3752                    .as_ref()
3753                    .map(<Ipv4Configuration as fidl::encoding::ValueTypeMarker>::borrow),
3754                encoder,
3755                offset + cur_offset,
3756                depth,
3757            )?;
3758
3759            _prev_end_offset = cur_offset + envelope_size;
3760            if 2 > max_ordinal {
3761                return Ok(());
3762            }
3763
3764            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3765            // are envelope_size bytes.
3766            let cur_offset: usize = (2 - 1) * envelope_size;
3767
3768            // Zero reserved fields.
3769            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3770
3771            // Safety:
3772            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3773            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3774            //   envelope_size bytes, there is always sufficient room.
3775            fidl::encoding::encode_in_envelope_optional::<Ipv6Configuration, D>(
3776                self.ipv6
3777                    .as_ref()
3778                    .map(<Ipv6Configuration as fidl::encoding::ValueTypeMarker>::borrow),
3779                encoder,
3780                offset + cur_offset,
3781                depth,
3782            )?;
3783
3784            _prev_end_offset = cur_offset + envelope_size;
3785
3786            Ok(())
3787        }
3788    }
3789
3790    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Configuration {
3791        #[inline(always)]
3792        fn new_empty() -> Self {
3793            Self::default()
3794        }
3795
3796        unsafe fn decode(
3797            &mut self,
3798            decoder: &mut fidl::encoding::Decoder<'_, D>,
3799            offset: usize,
3800            mut depth: fidl::encoding::Depth,
3801        ) -> fidl::Result<()> {
3802            decoder.debug_check_bounds::<Self>(offset);
3803            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3804                None => return Err(fidl::Error::NotNullable),
3805                Some(len) => len,
3806            };
3807            // Calling decoder.out_of_line_offset(0) is not allowed.
3808            if len == 0 {
3809                return Ok(());
3810            };
3811            depth.increment()?;
3812            let envelope_size = 8;
3813            let bytes_len = len * envelope_size;
3814            let offset = decoder.out_of_line_offset(bytes_len)?;
3815            // Decode the envelope for each type.
3816            let mut _next_ordinal_to_read = 0;
3817            let mut next_offset = offset;
3818            let end_offset = offset + bytes_len;
3819            _next_ordinal_to_read += 1;
3820            if next_offset >= end_offset {
3821                return Ok(());
3822            }
3823
3824            // Decode unknown envelopes for gaps in ordinals.
3825            while _next_ordinal_to_read < 1 {
3826                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3827                _next_ordinal_to_read += 1;
3828                next_offset += envelope_size;
3829            }
3830
3831            let next_out_of_line = decoder.next_out_of_line();
3832            let handles_before = decoder.remaining_handles();
3833            if let Some((inlined, num_bytes, num_handles)) =
3834                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3835            {
3836                let member_inline_size =
3837                    <Ipv4Configuration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3838                if inlined != (member_inline_size <= 4) {
3839                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3840                }
3841                let inner_offset;
3842                let mut inner_depth = depth.clone();
3843                if inlined {
3844                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3845                    inner_offset = next_offset;
3846                } else {
3847                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3848                    inner_depth.increment()?;
3849                }
3850                let val_ref =
3851                    self.ipv4.get_or_insert_with(|| fidl::new_empty!(Ipv4Configuration, D));
3852                fidl::decode!(Ipv4Configuration, D, val_ref, decoder, inner_offset, inner_depth)?;
3853                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3854                {
3855                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3856                }
3857                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3858                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3859                }
3860            }
3861
3862            next_offset += envelope_size;
3863            _next_ordinal_to_read += 1;
3864            if next_offset >= end_offset {
3865                return Ok(());
3866            }
3867
3868            // Decode unknown envelopes for gaps in ordinals.
3869            while _next_ordinal_to_read < 2 {
3870                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3871                _next_ordinal_to_read += 1;
3872                next_offset += envelope_size;
3873            }
3874
3875            let next_out_of_line = decoder.next_out_of_line();
3876            let handles_before = decoder.remaining_handles();
3877            if let Some((inlined, num_bytes, num_handles)) =
3878                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3879            {
3880                let member_inline_size =
3881                    <Ipv6Configuration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3882                if inlined != (member_inline_size <= 4) {
3883                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3884                }
3885                let inner_offset;
3886                let mut inner_depth = depth.clone();
3887                if inlined {
3888                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3889                    inner_offset = next_offset;
3890                } else {
3891                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3892                    inner_depth.increment()?;
3893                }
3894                let val_ref =
3895                    self.ipv6.get_or_insert_with(|| fidl::new_empty!(Ipv6Configuration, D));
3896                fidl::decode!(Ipv6Configuration, D, val_ref, decoder, inner_offset, inner_depth)?;
3897                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3898                {
3899                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3900                }
3901                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3902                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3903                }
3904            }
3905
3906            next_offset += envelope_size;
3907
3908            // Decode the remaining unknown envelopes.
3909            while next_offset < end_offset {
3910                _next_ordinal_to_read += 1;
3911                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3912                next_offset += envelope_size;
3913            }
3914
3915            Ok(())
3916        }
3917    }
3918
3919    impl DadConfiguration {
3920        #[inline(always)]
3921        fn max_ordinal_present(&self) -> u64 {
3922            if let Some(_) = self.transmits {
3923                return 1;
3924            }
3925            0
3926        }
3927    }
3928
3929    impl fidl::encoding::ValueTypeMarker for DadConfiguration {
3930        type Borrowed<'a> = &'a Self;
3931        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3932            value
3933        }
3934    }
3935
3936    unsafe impl fidl::encoding::TypeMarker for DadConfiguration {
3937        type Owned = Self;
3938
3939        #[inline(always)]
3940        fn inline_align(_context: fidl::encoding::Context) -> usize {
3941            8
3942        }
3943
3944        #[inline(always)]
3945        fn inline_size(_context: fidl::encoding::Context) -> usize {
3946            16
3947        }
3948    }
3949
3950    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<DadConfiguration, D>
3951        for &DadConfiguration
3952    {
3953        unsafe fn encode(
3954            self,
3955            encoder: &mut fidl::encoding::Encoder<'_, D>,
3956            offset: usize,
3957            mut depth: fidl::encoding::Depth,
3958        ) -> fidl::Result<()> {
3959            encoder.debug_check_bounds::<DadConfiguration>(offset);
3960            // Vector header
3961            let max_ordinal: u64 = self.max_ordinal_present();
3962            encoder.write_num(max_ordinal, offset);
3963            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3964            // Calling encoder.out_of_line_offset(0) is not allowed.
3965            if max_ordinal == 0 {
3966                return Ok(());
3967            }
3968            depth.increment()?;
3969            let envelope_size = 8;
3970            let bytes_len = max_ordinal as usize * envelope_size;
3971            #[allow(unused_variables)]
3972            let offset = encoder.out_of_line_offset(bytes_len);
3973            let mut _prev_end_offset: usize = 0;
3974            if 1 > max_ordinal {
3975                return Ok(());
3976            }
3977
3978            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3979            // are envelope_size bytes.
3980            let cur_offset: usize = (1 - 1) * envelope_size;
3981
3982            // Zero reserved fields.
3983            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3984
3985            // Safety:
3986            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3987            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3988            //   envelope_size bytes, there is always sufficient room.
3989            fidl::encoding::encode_in_envelope_optional::<u16, D>(
3990                self.transmits.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
3991                encoder,
3992                offset + cur_offset,
3993                depth,
3994            )?;
3995
3996            _prev_end_offset = cur_offset + envelope_size;
3997
3998            Ok(())
3999        }
4000    }
4001
4002    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for DadConfiguration {
4003        #[inline(always)]
4004        fn new_empty() -> Self {
4005            Self::default()
4006        }
4007
4008        unsafe fn decode(
4009            &mut self,
4010            decoder: &mut fidl::encoding::Decoder<'_, D>,
4011            offset: usize,
4012            mut depth: fidl::encoding::Depth,
4013        ) -> fidl::Result<()> {
4014            decoder.debug_check_bounds::<Self>(offset);
4015            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4016                None => return Err(fidl::Error::NotNullable),
4017                Some(len) => len,
4018            };
4019            // Calling decoder.out_of_line_offset(0) is not allowed.
4020            if len == 0 {
4021                return Ok(());
4022            };
4023            depth.increment()?;
4024            let envelope_size = 8;
4025            let bytes_len = len * envelope_size;
4026            let offset = decoder.out_of_line_offset(bytes_len)?;
4027            // Decode the envelope for each type.
4028            let mut _next_ordinal_to_read = 0;
4029            let mut next_offset = offset;
4030            let end_offset = offset + bytes_len;
4031            _next_ordinal_to_read += 1;
4032            if next_offset >= end_offset {
4033                return Ok(());
4034            }
4035
4036            // Decode unknown envelopes for gaps in ordinals.
4037            while _next_ordinal_to_read < 1 {
4038                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4039                _next_ordinal_to_read += 1;
4040                next_offset += envelope_size;
4041            }
4042
4043            let next_out_of_line = decoder.next_out_of_line();
4044            let handles_before = decoder.remaining_handles();
4045            if let Some((inlined, num_bytes, num_handles)) =
4046                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4047            {
4048                let member_inline_size =
4049                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4050                if inlined != (member_inline_size <= 4) {
4051                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4052                }
4053                let inner_offset;
4054                let mut inner_depth = depth.clone();
4055                if inlined {
4056                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4057                    inner_offset = next_offset;
4058                } else {
4059                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4060                    inner_depth.increment()?;
4061                }
4062                let val_ref = self.transmits.get_or_insert_with(|| fidl::new_empty!(u16, D));
4063                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
4064                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4065                {
4066                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4067                }
4068                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4069                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4070                }
4071            }
4072
4073            next_offset += envelope_size;
4074
4075            // Decode the remaining unknown envelopes.
4076            while next_offset < end_offset {
4077                _next_ordinal_to_read += 1;
4078                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4079                next_offset += envelope_size;
4080            }
4081
4082            Ok(())
4083        }
4084    }
4085
4086    impl IgmpConfiguration {
4087        #[inline(always)]
4088        fn max_ordinal_present(&self) -> u64 {
4089            if let Some(_) = self.version {
4090                return 1;
4091            }
4092            0
4093        }
4094    }
4095
4096    impl fidl::encoding::ValueTypeMarker for IgmpConfiguration {
4097        type Borrowed<'a> = &'a Self;
4098        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4099            value
4100        }
4101    }
4102
4103    unsafe impl fidl::encoding::TypeMarker for IgmpConfiguration {
4104        type Owned = Self;
4105
4106        #[inline(always)]
4107        fn inline_align(_context: fidl::encoding::Context) -> usize {
4108            8
4109        }
4110
4111        #[inline(always)]
4112        fn inline_size(_context: fidl::encoding::Context) -> usize {
4113            16
4114        }
4115    }
4116
4117    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<IgmpConfiguration, D>
4118        for &IgmpConfiguration
4119    {
4120        unsafe fn encode(
4121            self,
4122            encoder: &mut fidl::encoding::Encoder<'_, D>,
4123            offset: usize,
4124            mut depth: fidl::encoding::Depth,
4125        ) -> fidl::Result<()> {
4126            encoder.debug_check_bounds::<IgmpConfiguration>(offset);
4127            // Vector header
4128            let max_ordinal: u64 = self.max_ordinal_present();
4129            encoder.write_num(max_ordinal, offset);
4130            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4131            // Calling encoder.out_of_line_offset(0) is not allowed.
4132            if max_ordinal == 0 {
4133                return Ok(());
4134            }
4135            depth.increment()?;
4136            let envelope_size = 8;
4137            let bytes_len = max_ordinal as usize * envelope_size;
4138            #[allow(unused_variables)]
4139            let offset = encoder.out_of_line_offset(bytes_len);
4140            let mut _prev_end_offset: usize = 0;
4141            if 1 > max_ordinal {
4142                return Ok(());
4143            }
4144
4145            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4146            // are envelope_size bytes.
4147            let cur_offset: usize = (1 - 1) * envelope_size;
4148
4149            // Zero reserved fields.
4150            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4151
4152            // Safety:
4153            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4154            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4155            //   envelope_size bytes, there is always sufficient room.
4156            fidl::encoding::encode_in_envelope_optional::<IgmpVersion, D>(
4157                self.version.as_ref().map(<IgmpVersion as fidl::encoding::ValueTypeMarker>::borrow),
4158                encoder,
4159                offset + cur_offset,
4160                depth,
4161            )?;
4162
4163            _prev_end_offset = cur_offset + envelope_size;
4164
4165            Ok(())
4166        }
4167    }
4168
4169    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for IgmpConfiguration {
4170        #[inline(always)]
4171        fn new_empty() -> Self {
4172            Self::default()
4173        }
4174
4175        unsafe fn decode(
4176            &mut self,
4177            decoder: &mut fidl::encoding::Decoder<'_, D>,
4178            offset: usize,
4179            mut depth: fidl::encoding::Depth,
4180        ) -> fidl::Result<()> {
4181            decoder.debug_check_bounds::<Self>(offset);
4182            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4183                None => return Err(fidl::Error::NotNullable),
4184                Some(len) => len,
4185            };
4186            // Calling decoder.out_of_line_offset(0) is not allowed.
4187            if len == 0 {
4188                return Ok(());
4189            };
4190            depth.increment()?;
4191            let envelope_size = 8;
4192            let bytes_len = len * envelope_size;
4193            let offset = decoder.out_of_line_offset(bytes_len)?;
4194            // Decode the envelope for each type.
4195            let mut _next_ordinal_to_read = 0;
4196            let mut next_offset = offset;
4197            let end_offset = offset + bytes_len;
4198            _next_ordinal_to_read += 1;
4199            if next_offset >= end_offset {
4200                return Ok(());
4201            }
4202
4203            // Decode unknown envelopes for gaps in ordinals.
4204            while _next_ordinal_to_read < 1 {
4205                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4206                _next_ordinal_to_read += 1;
4207                next_offset += envelope_size;
4208            }
4209
4210            let next_out_of_line = decoder.next_out_of_line();
4211            let handles_before = decoder.remaining_handles();
4212            if let Some((inlined, num_bytes, num_handles)) =
4213                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4214            {
4215                let member_inline_size =
4216                    <IgmpVersion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4217                if inlined != (member_inline_size <= 4) {
4218                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4219                }
4220                let inner_offset;
4221                let mut inner_depth = depth.clone();
4222                if inlined {
4223                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4224                    inner_offset = next_offset;
4225                } else {
4226                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4227                    inner_depth.increment()?;
4228                }
4229                let val_ref = self.version.get_or_insert_with(|| fidl::new_empty!(IgmpVersion, D));
4230                fidl::decode!(IgmpVersion, D, val_ref, decoder, inner_offset, inner_depth)?;
4231                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4232                {
4233                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4234                }
4235                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4236                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4237                }
4238            }
4239
4240            next_offset += envelope_size;
4241
4242            // Decode the remaining unknown envelopes.
4243            while next_offset < end_offset {
4244                _next_ordinal_to_read += 1;
4245                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4246                next_offset += envelope_size;
4247            }
4248
4249            Ok(())
4250        }
4251    }
4252
4253    impl Ipv4Configuration {
4254        #[inline(always)]
4255        fn max_ordinal_present(&self) -> u64 {
4256            if let Some(_) = self.arp {
4257                return 4;
4258            }
4259            if let Some(_) = self.igmp {
4260                return 3;
4261            }
4262            if let Some(_) = self.multicast_forwarding {
4263                return 2;
4264            }
4265            if let Some(_) = self.unicast_forwarding {
4266                return 1;
4267            }
4268            0
4269        }
4270    }
4271
4272    impl fidl::encoding::ValueTypeMarker for Ipv4Configuration {
4273        type Borrowed<'a> = &'a Self;
4274        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4275            value
4276        }
4277    }
4278
4279    unsafe impl fidl::encoding::TypeMarker for Ipv4Configuration {
4280        type Owned = Self;
4281
4282        #[inline(always)]
4283        fn inline_align(_context: fidl::encoding::Context) -> usize {
4284            8
4285        }
4286
4287        #[inline(always)]
4288        fn inline_size(_context: fidl::encoding::Context) -> usize {
4289            16
4290        }
4291    }
4292
4293    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Ipv4Configuration, D>
4294        for &Ipv4Configuration
4295    {
4296        unsafe fn encode(
4297            self,
4298            encoder: &mut fidl::encoding::Encoder<'_, D>,
4299            offset: usize,
4300            mut depth: fidl::encoding::Depth,
4301        ) -> fidl::Result<()> {
4302            encoder.debug_check_bounds::<Ipv4Configuration>(offset);
4303            // Vector header
4304            let max_ordinal: u64 = self.max_ordinal_present();
4305            encoder.write_num(max_ordinal, offset);
4306            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4307            // Calling encoder.out_of_line_offset(0) is not allowed.
4308            if max_ordinal == 0 {
4309                return Ok(());
4310            }
4311            depth.increment()?;
4312            let envelope_size = 8;
4313            let bytes_len = max_ordinal as usize * envelope_size;
4314            #[allow(unused_variables)]
4315            let offset = encoder.out_of_line_offset(bytes_len);
4316            let mut _prev_end_offset: usize = 0;
4317            if 1 > max_ordinal {
4318                return Ok(());
4319            }
4320
4321            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4322            // are envelope_size bytes.
4323            let cur_offset: usize = (1 - 1) * envelope_size;
4324
4325            // Zero reserved fields.
4326            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4327
4328            // Safety:
4329            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4330            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4331            //   envelope_size bytes, there is always sufficient room.
4332            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4333                self.unicast_forwarding
4334                    .as_ref()
4335                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4336                encoder,
4337                offset + cur_offset,
4338                depth,
4339            )?;
4340
4341            _prev_end_offset = cur_offset + envelope_size;
4342            if 2 > max_ordinal {
4343                return Ok(());
4344            }
4345
4346            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4347            // are envelope_size bytes.
4348            let cur_offset: usize = (2 - 1) * envelope_size;
4349
4350            // Zero reserved fields.
4351            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4352
4353            // Safety:
4354            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4355            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4356            //   envelope_size bytes, there is always sufficient room.
4357            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4358                self.multicast_forwarding
4359                    .as_ref()
4360                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4361                encoder,
4362                offset + cur_offset,
4363                depth,
4364            )?;
4365
4366            _prev_end_offset = cur_offset + envelope_size;
4367            if 3 > max_ordinal {
4368                return Ok(());
4369            }
4370
4371            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4372            // are envelope_size bytes.
4373            let cur_offset: usize = (3 - 1) * envelope_size;
4374
4375            // Zero reserved fields.
4376            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4377
4378            // Safety:
4379            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4380            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4381            //   envelope_size bytes, there is always sufficient room.
4382            fidl::encoding::encode_in_envelope_optional::<IgmpConfiguration, D>(
4383                self.igmp
4384                    .as_ref()
4385                    .map(<IgmpConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
4386                encoder,
4387                offset + cur_offset,
4388                depth,
4389            )?;
4390
4391            _prev_end_offset = cur_offset + envelope_size;
4392            if 4 > max_ordinal {
4393                return Ok(());
4394            }
4395
4396            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4397            // are envelope_size bytes.
4398            let cur_offset: usize = (4 - 1) * envelope_size;
4399
4400            // Zero reserved fields.
4401            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4402
4403            // Safety:
4404            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4405            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4406            //   envelope_size bytes, there is always sufficient room.
4407            fidl::encoding::encode_in_envelope_optional::<ArpConfiguration, D>(
4408                self.arp
4409                    .as_ref()
4410                    .map(<ArpConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
4411                encoder,
4412                offset + cur_offset,
4413                depth,
4414            )?;
4415
4416            _prev_end_offset = cur_offset + envelope_size;
4417
4418            Ok(())
4419        }
4420    }
4421
4422    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Ipv4Configuration {
4423        #[inline(always)]
4424        fn new_empty() -> Self {
4425            Self::default()
4426        }
4427
4428        unsafe fn decode(
4429            &mut self,
4430            decoder: &mut fidl::encoding::Decoder<'_, D>,
4431            offset: usize,
4432            mut depth: fidl::encoding::Depth,
4433        ) -> fidl::Result<()> {
4434            decoder.debug_check_bounds::<Self>(offset);
4435            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4436                None => return Err(fidl::Error::NotNullable),
4437                Some(len) => len,
4438            };
4439            // Calling decoder.out_of_line_offset(0) is not allowed.
4440            if len == 0 {
4441                return Ok(());
4442            };
4443            depth.increment()?;
4444            let envelope_size = 8;
4445            let bytes_len = len * envelope_size;
4446            let offset = decoder.out_of_line_offset(bytes_len)?;
4447            // Decode the envelope for each type.
4448            let mut _next_ordinal_to_read = 0;
4449            let mut next_offset = offset;
4450            let end_offset = offset + bytes_len;
4451            _next_ordinal_to_read += 1;
4452            if next_offset >= end_offset {
4453                return Ok(());
4454            }
4455
4456            // Decode unknown envelopes for gaps in ordinals.
4457            while _next_ordinal_to_read < 1 {
4458                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4459                _next_ordinal_to_read += 1;
4460                next_offset += envelope_size;
4461            }
4462
4463            let next_out_of_line = decoder.next_out_of_line();
4464            let handles_before = decoder.remaining_handles();
4465            if let Some((inlined, num_bytes, num_handles)) =
4466                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4467            {
4468                let member_inline_size =
4469                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4470                if inlined != (member_inline_size <= 4) {
4471                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4472                }
4473                let inner_offset;
4474                let mut inner_depth = depth.clone();
4475                if inlined {
4476                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4477                    inner_offset = next_offset;
4478                } else {
4479                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4480                    inner_depth.increment()?;
4481                }
4482                let val_ref =
4483                    self.unicast_forwarding.get_or_insert_with(|| fidl::new_empty!(bool, D));
4484                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4485                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4486                {
4487                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4488                }
4489                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4490                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4491                }
4492            }
4493
4494            next_offset += envelope_size;
4495            _next_ordinal_to_read += 1;
4496            if next_offset >= end_offset {
4497                return Ok(());
4498            }
4499
4500            // Decode unknown envelopes for gaps in ordinals.
4501            while _next_ordinal_to_read < 2 {
4502                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4503                _next_ordinal_to_read += 1;
4504                next_offset += envelope_size;
4505            }
4506
4507            let next_out_of_line = decoder.next_out_of_line();
4508            let handles_before = decoder.remaining_handles();
4509            if let Some((inlined, num_bytes, num_handles)) =
4510                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4511            {
4512                let member_inline_size =
4513                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4514                if inlined != (member_inline_size <= 4) {
4515                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4516                }
4517                let inner_offset;
4518                let mut inner_depth = depth.clone();
4519                if inlined {
4520                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4521                    inner_offset = next_offset;
4522                } else {
4523                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4524                    inner_depth.increment()?;
4525                }
4526                let val_ref =
4527                    self.multicast_forwarding.get_or_insert_with(|| fidl::new_empty!(bool, D));
4528                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4529                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4530                {
4531                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4532                }
4533                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4534                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4535                }
4536            }
4537
4538            next_offset += envelope_size;
4539            _next_ordinal_to_read += 1;
4540            if next_offset >= end_offset {
4541                return Ok(());
4542            }
4543
4544            // Decode unknown envelopes for gaps in ordinals.
4545            while _next_ordinal_to_read < 3 {
4546                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4547                _next_ordinal_to_read += 1;
4548                next_offset += envelope_size;
4549            }
4550
4551            let next_out_of_line = decoder.next_out_of_line();
4552            let handles_before = decoder.remaining_handles();
4553            if let Some((inlined, num_bytes, num_handles)) =
4554                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4555            {
4556                let member_inline_size =
4557                    <IgmpConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4558                if inlined != (member_inline_size <= 4) {
4559                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4560                }
4561                let inner_offset;
4562                let mut inner_depth = depth.clone();
4563                if inlined {
4564                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4565                    inner_offset = next_offset;
4566                } else {
4567                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4568                    inner_depth.increment()?;
4569                }
4570                let val_ref =
4571                    self.igmp.get_or_insert_with(|| fidl::new_empty!(IgmpConfiguration, D));
4572                fidl::decode!(IgmpConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
4573                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4574                {
4575                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4576                }
4577                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4578                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4579                }
4580            }
4581
4582            next_offset += envelope_size;
4583            _next_ordinal_to_read += 1;
4584            if next_offset >= end_offset {
4585                return Ok(());
4586            }
4587
4588            // Decode unknown envelopes for gaps in ordinals.
4589            while _next_ordinal_to_read < 4 {
4590                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4591                _next_ordinal_to_read += 1;
4592                next_offset += envelope_size;
4593            }
4594
4595            let next_out_of_line = decoder.next_out_of_line();
4596            let handles_before = decoder.remaining_handles();
4597            if let Some((inlined, num_bytes, num_handles)) =
4598                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4599            {
4600                let member_inline_size =
4601                    <ArpConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4602                if inlined != (member_inline_size <= 4) {
4603                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4604                }
4605                let inner_offset;
4606                let mut inner_depth = depth.clone();
4607                if inlined {
4608                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4609                    inner_offset = next_offset;
4610                } else {
4611                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4612                    inner_depth.increment()?;
4613                }
4614                let val_ref = self.arp.get_or_insert_with(|| fidl::new_empty!(ArpConfiguration, D));
4615                fidl::decode!(ArpConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
4616                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4617                {
4618                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4619                }
4620                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4621                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4622                }
4623            }
4624
4625            next_offset += envelope_size;
4626
4627            // Decode the remaining unknown envelopes.
4628            while next_offset < end_offset {
4629                _next_ordinal_to_read += 1;
4630                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4631                next_offset += envelope_size;
4632            }
4633
4634            Ok(())
4635        }
4636    }
4637
4638    impl Ipv6Configuration {
4639        #[inline(always)]
4640        fn max_ordinal_present(&self) -> u64 {
4641            if let Some(_) = self.ndp {
4642                return 4;
4643            }
4644            if let Some(_) = self.mld {
4645                return 3;
4646            }
4647            if let Some(_) = self.multicast_forwarding {
4648                return 2;
4649            }
4650            if let Some(_) = self.unicast_forwarding {
4651                return 1;
4652            }
4653            0
4654        }
4655    }
4656
4657    impl fidl::encoding::ValueTypeMarker for Ipv6Configuration {
4658        type Borrowed<'a> = &'a Self;
4659        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4660            value
4661        }
4662    }
4663
4664    unsafe impl fidl::encoding::TypeMarker for Ipv6Configuration {
4665        type Owned = Self;
4666
4667        #[inline(always)]
4668        fn inline_align(_context: fidl::encoding::Context) -> usize {
4669            8
4670        }
4671
4672        #[inline(always)]
4673        fn inline_size(_context: fidl::encoding::Context) -> usize {
4674            16
4675        }
4676    }
4677
4678    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Ipv6Configuration, D>
4679        for &Ipv6Configuration
4680    {
4681        unsafe fn encode(
4682            self,
4683            encoder: &mut fidl::encoding::Encoder<'_, D>,
4684            offset: usize,
4685            mut depth: fidl::encoding::Depth,
4686        ) -> fidl::Result<()> {
4687            encoder.debug_check_bounds::<Ipv6Configuration>(offset);
4688            // Vector header
4689            let max_ordinal: u64 = self.max_ordinal_present();
4690            encoder.write_num(max_ordinal, offset);
4691            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4692            // Calling encoder.out_of_line_offset(0) is not allowed.
4693            if max_ordinal == 0 {
4694                return Ok(());
4695            }
4696            depth.increment()?;
4697            let envelope_size = 8;
4698            let bytes_len = max_ordinal as usize * envelope_size;
4699            #[allow(unused_variables)]
4700            let offset = encoder.out_of_line_offset(bytes_len);
4701            let mut _prev_end_offset: usize = 0;
4702            if 1 > max_ordinal {
4703                return Ok(());
4704            }
4705
4706            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4707            // are envelope_size bytes.
4708            let cur_offset: usize = (1 - 1) * envelope_size;
4709
4710            // Zero reserved fields.
4711            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4712
4713            // Safety:
4714            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4715            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4716            //   envelope_size bytes, there is always sufficient room.
4717            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4718                self.unicast_forwarding
4719                    .as_ref()
4720                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4721                encoder,
4722                offset + cur_offset,
4723                depth,
4724            )?;
4725
4726            _prev_end_offset = cur_offset + envelope_size;
4727            if 2 > max_ordinal {
4728                return Ok(());
4729            }
4730
4731            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4732            // are envelope_size bytes.
4733            let cur_offset: usize = (2 - 1) * envelope_size;
4734
4735            // Zero reserved fields.
4736            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4737
4738            // Safety:
4739            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4740            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4741            //   envelope_size bytes, there is always sufficient room.
4742            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4743                self.multicast_forwarding
4744                    .as_ref()
4745                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4746                encoder,
4747                offset + cur_offset,
4748                depth,
4749            )?;
4750
4751            _prev_end_offset = cur_offset + envelope_size;
4752            if 3 > max_ordinal {
4753                return Ok(());
4754            }
4755
4756            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4757            // are envelope_size bytes.
4758            let cur_offset: usize = (3 - 1) * envelope_size;
4759
4760            // Zero reserved fields.
4761            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4762
4763            // Safety:
4764            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4765            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4766            //   envelope_size bytes, there is always sufficient room.
4767            fidl::encoding::encode_in_envelope_optional::<MldConfiguration, D>(
4768                self.mld
4769                    .as_ref()
4770                    .map(<MldConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
4771                encoder,
4772                offset + cur_offset,
4773                depth,
4774            )?;
4775
4776            _prev_end_offset = cur_offset + envelope_size;
4777            if 4 > max_ordinal {
4778                return Ok(());
4779            }
4780
4781            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4782            // are envelope_size bytes.
4783            let cur_offset: usize = (4 - 1) * envelope_size;
4784
4785            // Zero reserved fields.
4786            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4787
4788            // Safety:
4789            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4790            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4791            //   envelope_size bytes, there is always sufficient room.
4792            fidl::encoding::encode_in_envelope_optional::<NdpConfiguration, D>(
4793                self.ndp
4794                    .as_ref()
4795                    .map(<NdpConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
4796                encoder,
4797                offset + cur_offset,
4798                depth,
4799            )?;
4800
4801            _prev_end_offset = cur_offset + envelope_size;
4802
4803            Ok(())
4804        }
4805    }
4806
4807    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Ipv6Configuration {
4808        #[inline(always)]
4809        fn new_empty() -> Self {
4810            Self::default()
4811        }
4812
4813        unsafe fn decode(
4814            &mut self,
4815            decoder: &mut fidl::encoding::Decoder<'_, D>,
4816            offset: usize,
4817            mut depth: fidl::encoding::Depth,
4818        ) -> fidl::Result<()> {
4819            decoder.debug_check_bounds::<Self>(offset);
4820            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4821                None => return Err(fidl::Error::NotNullable),
4822                Some(len) => len,
4823            };
4824            // Calling decoder.out_of_line_offset(0) is not allowed.
4825            if len == 0 {
4826                return Ok(());
4827            };
4828            depth.increment()?;
4829            let envelope_size = 8;
4830            let bytes_len = len * envelope_size;
4831            let offset = decoder.out_of_line_offset(bytes_len)?;
4832            // Decode the envelope for each type.
4833            let mut _next_ordinal_to_read = 0;
4834            let mut next_offset = offset;
4835            let end_offset = offset + bytes_len;
4836            _next_ordinal_to_read += 1;
4837            if next_offset >= end_offset {
4838                return Ok(());
4839            }
4840
4841            // Decode unknown envelopes for gaps in ordinals.
4842            while _next_ordinal_to_read < 1 {
4843                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4844                _next_ordinal_to_read += 1;
4845                next_offset += envelope_size;
4846            }
4847
4848            let next_out_of_line = decoder.next_out_of_line();
4849            let handles_before = decoder.remaining_handles();
4850            if let Some((inlined, num_bytes, num_handles)) =
4851                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4852            {
4853                let member_inline_size =
4854                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4855                if inlined != (member_inline_size <= 4) {
4856                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4857                }
4858                let inner_offset;
4859                let mut inner_depth = depth.clone();
4860                if inlined {
4861                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4862                    inner_offset = next_offset;
4863                } else {
4864                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4865                    inner_depth.increment()?;
4866                }
4867                let val_ref =
4868                    self.unicast_forwarding.get_or_insert_with(|| fidl::new_empty!(bool, D));
4869                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4870                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4871                {
4872                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4873                }
4874                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4875                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4876                }
4877            }
4878
4879            next_offset += envelope_size;
4880            _next_ordinal_to_read += 1;
4881            if next_offset >= end_offset {
4882                return Ok(());
4883            }
4884
4885            // Decode unknown envelopes for gaps in ordinals.
4886            while _next_ordinal_to_read < 2 {
4887                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4888                _next_ordinal_to_read += 1;
4889                next_offset += envelope_size;
4890            }
4891
4892            let next_out_of_line = decoder.next_out_of_line();
4893            let handles_before = decoder.remaining_handles();
4894            if let Some((inlined, num_bytes, num_handles)) =
4895                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4896            {
4897                let member_inline_size =
4898                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4899                if inlined != (member_inline_size <= 4) {
4900                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4901                }
4902                let inner_offset;
4903                let mut inner_depth = depth.clone();
4904                if inlined {
4905                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4906                    inner_offset = next_offset;
4907                } else {
4908                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4909                    inner_depth.increment()?;
4910                }
4911                let val_ref =
4912                    self.multicast_forwarding.get_or_insert_with(|| fidl::new_empty!(bool, D));
4913                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4914                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4915                {
4916                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4917                }
4918                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4919                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4920                }
4921            }
4922
4923            next_offset += envelope_size;
4924            _next_ordinal_to_read += 1;
4925            if next_offset >= end_offset {
4926                return Ok(());
4927            }
4928
4929            // Decode unknown envelopes for gaps in ordinals.
4930            while _next_ordinal_to_read < 3 {
4931                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4932                _next_ordinal_to_read += 1;
4933                next_offset += envelope_size;
4934            }
4935
4936            let next_out_of_line = decoder.next_out_of_line();
4937            let handles_before = decoder.remaining_handles();
4938            if let Some((inlined, num_bytes, num_handles)) =
4939                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4940            {
4941                let member_inline_size =
4942                    <MldConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4943                if inlined != (member_inline_size <= 4) {
4944                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4945                }
4946                let inner_offset;
4947                let mut inner_depth = depth.clone();
4948                if inlined {
4949                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4950                    inner_offset = next_offset;
4951                } else {
4952                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4953                    inner_depth.increment()?;
4954                }
4955                let val_ref = self.mld.get_or_insert_with(|| fidl::new_empty!(MldConfiguration, D));
4956                fidl::decode!(MldConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
4957                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4958                {
4959                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4960                }
4961                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4962                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4963                }
4964            }
4965
4966            next_offset += envelope_size;
4967            _next_ordinal_to_read += 1;
4968            if next_offset >= end_offset {
4969                return Ok(());
4970            }
4971
4972            // Decode unknown envelopes for gaps in ordinals.
4973            while _next_ordinal_to_read < 4 {
4974                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4975                _next_ordinal_to_read += 1;
4976                next_offset += envelope_size;
4977            }
4978
4979            let next_out_of_line = decoder.next_out_of_line();
4980            let handles_before = decoder.remaining_handles();
4981            if let Some((inlined, num_bytes, num_handles)) =
4982                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4983            {
4984                let member_inline_size =
4985                    <NdpConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4986                if inlined != (member_inline_size <= 4) {
4987                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4988                }
4989                let inner_offset;
4990                let mut inner_depth = depth.clone();
4991                if inlined {
4992                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4993                    inner_offset = next_offset;
4994                } else {
4995                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4996                    inner_depth.increment()?;
4997                }
4998                let val_ref = self.ndp.get_or_insert_with(|| fidl::new_empty!(NdpConfiguration, D));
4999                fidl::decode!(NdpConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
5000                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5001                {
5002                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5003                }
5004                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5005                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5006                }
5007            }
5008
5009            next_offset += envelope_size;
5010
5011            // Decode the remaining unknown envelopes.
5012            while next_offset < end_offset {
5013                _next_ordinal_to_read += 1;
5014                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5015                next_offset += envelope_size;
5016            }
5017
5018            Ok(())
5019        }
5020    }
5021
5022    impl MldConfiguration {
5023        #[inline(always)]
5024        fn max_ordinal_present(&self) -> u64 {
5025            if let Some(_) = self.version {
5026                return 1;
5027            }
5028            0
5029        }
5030    }
5031
5032    impl fidl::encoding::ValueTypeMarker for MldConfiguration {
5033        type Borrowed<'a> = &'a Self;
5034        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5035            value
5036        }
5037    }
5038
5039    unsafe impl fidl::encoding::TypeMarker for MldConfiguration {
5040        type Owned = Self;
5041
5042        #[inline(always)]
5043        fn inline_align(_context: fidl::encoding::Context) -> usize {
5044            8
5045        }
5046
5047        #[inline(always)]
5048        fn inline_size(_context: fidl::encoding::Context) -> usize {
5049            16
5050        }
5051    }
5052
5053    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MldConfiguration, D>
5054        for &MldConfiguration
5055    {
5056        unsafe fn encode(
5057            self,
5058            encoder: &mut fidl::encoding::Encoder<'_, D>,
5059            offset: usize,
5060            mut depth: fidl::encoding::Depth,
5061        ) -> fidl::Result<()> {
5062            encoder.debug_check_bounds::<MldConfiguration>(offset);
5063            // Vector header
5064            let max_ordinal: u64 = self.max_ordinal_present();
5065            encoder.write_num(max_ordinal, offset);
5066            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5067            // Calling encoder.out_of_line_offset(0) is not allowed.
5068            if max_ordinal == 0 {
5069                return Ok(());
5070            }
5071            depth.increment()?;
5072            let envelope_size = 8;
5073            let bytes_len = max_ordinal as usize * envelope_size;
5074            #[allow(unused_variables)]
5075            let offset = encoder.out_of_line_offset(bytes_len);
5076            let mut _prev_end_offset: usize = 0;
5077            if 1 > max_ordinal {
5078                return Ok(());
5079            }
5080
5081            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5082            // are envelope_size bytes.
5083            let cur_offset: usize = (1 - 1) * envelope_size;
5084
5085            // Zero reserved fields.
5086            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5087
5088            // Safety:
5089            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5090            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5091            //   envelope_size bytes, there is always sufficient room.
5092            fidl::encoding::encode_in_envelope_optional::<MldVersion, D>(
5093                self.version.as_ref().map(<MldVersion as fidl::encoding::ValueTypeMarker>::borrow),
5094                encoder,
5095                offset + cur_offset,
5096                depth,
5097            )?;
5098
5099            _prev_end_offset = cur_offset + envelope_size;
5100
5101            Ok(())
5102        }
5103    }
5104
5105    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MldConfiguration {
5106        #[inline(always)]
5107        fn new_empty() -> Self {
5108            Self::default()
5109        }
5110
5111        unsafe fn decode(
5112            &mut self,
5113            decoder: &mut fidl::encoding::Decoder<'_, D>,
5114            offset: usize,
5115            mut depth: fidl::encoding::Depth,
5116        ) -> fidl::Result<()> {
5117            decoder.debug_check_bounds::<Self>(offset);
5118            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5119                None => return Err(fidl::Error::NotNullable),
5120                Some(len) => len,
5121            };
5122            // Calling decoder.out_of_line_offset(0) is not allowed.
5123            if len == 0 {
5124                return Ok(());
5125            };
5126            depth.increment()?;
5127            let envelope_size = 8;
5128            let bytes_len = len * envelope_size;
5129            let offset = decoder.out_of_line_offset(bytes_len)?;
5130            // Decode the envelope for each type.
5131            let mut _next_ordinal_to_read = 0;
5132            let mut next_offset = offset;
5133            let end_offset = offset + bytes_len;
5134            _next_ordinal_to_read += 1;
5135            if next_offset >= end_offset {
5136                return Ok(());
5137            }
5138
5139            // Decode unknown envelopes for gaps in ordinals.
5140            while _next_ordinal_to_read < 1 {
5141                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5142                _next_ordinal_to_read += 1;
5143                next_offset += envelope_size;
5144            }
5145
5146            let next_out_of_line = decoder.next_out_of_line();
5147            let handles_before = decoder.remaining_handles();
5148            if let Some((inlined, num_bytes, num_handles)) =
5149                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5150            {
5151                let member_inline_size =
5152                    <MldVersion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5153                if inlined != (member_inline_size <= 4) {
5154                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5155                }
5156                let inner_offset;
5157                let mut inner_depth = depth.clone();
5158                if inlined {
5159                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5160                    inner_offset = next_offset;
5161                } else {
5162                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5163                    inner_depth.increment()?;
5164                }
5165                let val_ref = self.version.get_or_insert_with(|| fidl::new_empty!(MldVersion, D));
5166                fidl::decode!(MldVersion, D, val_ref, decoder, inner_offset, inner_depth)?;
5167                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5168                {
5169                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5170                }
5171                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5172                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5173                }
5174            }
5175
5176            next_offset += envelope_size;
5177
5178            // Decode the remaining unknown envelopes.
5179            while next_offset < end_offset {
5180                _next_ordinal_to_read += 1;
5181                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5182                next_offset += envelope_size;
5183            }
5184
5185            Ok(())
5186        }
5187    }
5188
5189    impl NdpConfiguration {
5190        #[inline(always)]
5191        fn max_ordinal_present(&self) -> u64 {
5192            if let Some(_) = self.slaac {
5193                return 3;
5194            }
5195            if let Some(_) = self.dad {
5196                return 2;
5197            }
5198            if let Some(_) = self.nud {
5199                return 1;
5200            }
5201            0
5202        }
5203    }
5204
5205    impl fidl::encoding::ValueTypeMarker for NdpConfiguration {
5206        type Borrowed<'a> = &'a Self;
5207        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5208            value
5209        }
5210    }
5211
5212    unsafe impl fidl::encoding::TypeMarker for NdpConfiguration {
5213        type Owned = Self;
5214
5215        #[inline(always)]
5216        fn inline_align(_context: fidl::encoding::Context) -> usize {
5217            8
5218        }
5219
5220        #[inline(always)]
5221        fn inline_size(_context: fidl::encoding::Context) -> usize {
5222            16
5223        }
5224    }
5225
5226    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NdpConfiguration, D>
5227        for &NdpConfiguration
5228    {
5229        unsafe fn encode(
5230            self,
5231            encoder: &mut fidl::encoding::Encoder<'_, D>,
5232            offset: usize,
5233            mut depth: fidl::encoding::Depth,
5234        ) -> fidl::Result<()> {
5235            encoder.debug_check_bounds::<NdpConfiguration>(offset);
5236            // Vector header
5237            let max_ordinal: u64 = self.max_ordinal_present();
5238            encoder.write_num(max_ordinal, offset);
5239            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5240            // Calling encoder.out_of_line_offset(0) is not allowed.
5241            if max_ordinal == 0 {
5242                return Ok(());
5243            }
5244            depth.increment()?;
5245            let envelope_size = 8;
5246            let bytes_len = max_ordinal as usize * envelope_size;
5247            #[allow(unused_variables)]
5248            let offset = encoder.out_of_line_offset(bytes_len);
5249            let mut _prev_end_offset: usize = 0;
5250            if 1 > max_ordinal {
5251                return Ok(());
5252            }
5253
5254            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5255            // are envelope_size bytes.
5256            let cur_offset: usize = (1 - 1) * envelope_size;
5257
5258            // Zero reserved fields.
5259            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5260
5261            // Safety:
5262            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5263            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5264            //   envelope_size bytes, there is always sufficient room.
5265            fidl::encoding::encode_in_envelope_optional::<NudConfiguration, D>(
5266                self.nud
5267                    .as_ref()
5268                    .map(<NudConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
5269                encoder,
5270                offset + cur_offset,
5271                depth,
5272            )?;
5273
5274            _prev_end_offset = cur_offset + envelope_size;
5275            if 2 > max_ordinal {
5276                return Ok(());
5277            }
5278
5279            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5280            // are envelope_size bytes.
5281            let cur_offset: usize = (2 - 1) * envelope_size;
5282
5283            // Zero reserved fields.
5284            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5285
5286            // Safety:
5287            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5288            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5289            //   envelope_size bytes, there is always sufficient room.
5290            fidl::encoding::encode_in_envelope_optional::<DadConfiguration, D>(
5291                self.dad
5292                    .as_ref()
5293                    .map(<DadConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
5294                encoder,
5295                offset + cur_offset,
5296                depth,
5297            )?;
5298
5299            _prev_end_offset = cur_offset + envelope_size;
5300            if 3 > max_ordinal {
5301                return Ok(());
5302            }
5303
5304            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5305            // are envelope_size bytes.
5306            let cur_offset: usize = (3 - 1) * envelope_size;
5307
5308            // Zero reserved fields.
5309            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5310
5311            // Safety:
5312            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5313            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5314            //   envelope_size bytes, there is always sufficient room.
5315            fidl::encoding::encode_in_envelope_optional::<SlaacConfiguration, D>(
5316                self.slaac
5317                    .as_ref()
5318                    .map(<SlaacConfiguration as fidl::encoding::ValueTypeMarker>::borrow),
5319                encoder,
5320                offset + cur_offset,
5321                depth,
5322            )?;
5323
5324            _prev_end_offset = cur_offset + envelope_size;
5325
5326            Ok(())
5327        }
5328    }
5329
5330    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NdpConfiguration {
5331        #[inline(always)]
5332        fn new_empty() -> Self {
5333            Self::default()
5334        }
5335
5336        unsafe fn decode(
5337            &mut self,
5338            decoder: &mut fidl::encoding::Decoder<'_, D>,
5339            offset: usize,
5340            mut depth: fidl::encoding::Depth,
5341        ) -> fidl::Result<()> {
5342            decoder.debug_check_bounds::<Self>(offset);
5343            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5344                None => return Err(fidl::Error::NotNullable),
5345                Some(len) => len,
5346            };
5347            // Calling decoder.out_of_line_offset(0) is not allowed.
5348            if len == 0 {
5349                return Ok(());
5350            };
5351            depth.increment()?;
5352            let envelope_size = 8;
5353            let bytes_len = len * envelope_size;
5354            let offset = decoder.out_of_line_offset(bytes_len)?;
5355            // Decode the envelope for each type.
5356            let mut _next_ordinal_to_read = 0;
5357            let mut next_offset = offset;
5358            let end_offset = offset + bytes_len;
5359            _next_ordinal_to_read += 1;
5360            if next_offset >= end_offset {
5361                return Ok(());
5362            }
5363
5364            // Decode unknown envelopes for gaps in ordinals.
5365            while _next_ordinal_to_read < 1 {
5366                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5367                _next_ordinal_to_read += 1;
5368                next_offset += envelope_size;
5369            }
5370
5371            let next_out_of_line = decoder.next_out_of_line();
5372            let handles_before = decoder.remaining_handles();
5373            if let Some((inlined, num_bytes, num_handles)) =
5374                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5375            {
5376                let member_inline_size =
5377                    <NudConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5378                if inlined != (member_inline_size <= 4) {
5379                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5380                }
5381                let inner_offset;
5382                let mut inner_depth = depth.clone();
5383                if inlined {
5384                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5385                    inner_offset = next_offset;
5386                } else {
5387                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5388                    inner_depth.increment()?;
5389                }
5390                let val_ref = self.nud.get_or_insert_with(|| fidl::new_empty!(NudConfiguration, D));
5391                fidl::decode!(NudConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
5392                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5393                {
5394                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5395                }
5396                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5397                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5398                }
5399            }
5400
5401            next_offset += envelope_size;
5402            _next_ordinal_to_read += 1;
5403            if next_offset >= end_offset {
5404                return Ok(());
5405            }
5406
5407            // Decode unknown envelopes for gaps in ordinals.
5408            while _next_ordinal_to_read < 2 {
5409                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5410                _next_ordinal_to_read += 1;
5411                next_offset += envelope_size;
5412            }
5413
5414            let next_out_of_line = decoder.next_out_of_line();
5415            let handles_before = decoder.remaining_handles();
5416            if let Some((inlined, num_bytes, num_handles)) =
5417                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5418            {
5419                let member_inline_size =
5420                    <DadConfiguration as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5421                if inlined != (member_inline_size <= 4) {
5422                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5423                }
5424                let inner_offset;
5425                let mut inner_depth = depth.clone();
5426                if inlined {
5427                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5428                    inner_offset = next_offset;
5429                } else {
5430                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5431                    inner_depth.increment()?;
5432                }
5433                let val_ref = self.dad.get_or_insert_with(|| fidl::new_empty!(DadConfiguration, D));
5434                fidl::decode!(DadConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
5435                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5436                {
5437                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5438                }
5439                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5440                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5441                }
5442            }
5443
5444            next_offset += envelope_size;
5445            _next_ordinal_to_read += 1;
5446            if next_offset >= end_offset {
5447                return Ok(());
5448            }
5449
5450            // Decode unknown envelopes for gaps in ordinals.
5451            while _next_ordinal_to_read < 3 {
5452                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5453                _next_ordinal_to_read += 1;
5454                next_offset += envelope_size;
5455            }
5456
5457            let next_out_of_line = decoder.next_out_of_line();
5458            let handles_before = decoder.remaining_handles();
5459            if let Some((inlined, num_bytes, num_handles)) =
5460                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5461            {
5462                let member_inline_size =
5463                    <SlaacConfiguration as fidl::encoding::TypeMarker>::inline_size(
5464                        decoder.context,
5465                    );
5466                if inlined != (member_inline_size <= 4) {
5467                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5468                }
5469                let inner_offset;
5470                let mut inner_depth = depth.clone();
5471                if inlined {
5472                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5473                    inner_offset = next_offset;
5474                } else {
5475                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5476                    inner_depth.increment()?;
5477                }
5478                let val_ref =
5479                    self.slaac.get_or_insert_with(|| fidl::new_empty!(SlaacConfiguration, D));
5480                fidl::decode!(SlaacConfiguration, D, val_ref, decoder, inner_offset, inner_depth)?;
5481                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5482                {
5483                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5484                }
5485                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5486                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5487                }
5488            }
5489
5490            next_offset += envelope_size;
5491
5492            // Decode the remaining unknown envelopes.
5493            while next_offset < end_offset {
5494                _next_ordinal_to_read += 1;
5495                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5496                next_offset += envelope_size;
5497            }
5498
5499            Ok(())
5500        }
5501    }
5502
5503    impl NudConfiguration {
5504        #[inline(always)]
5505        fn max_ordinal_present(&self) -> u64 {
5506            if let Some(_) = self.base_reachable_time {
5507                return 3;
5508            }
5509            if let Some(_) = self.max_unicast_solicitations {
5510                return 2;
5511            }
5512            if let Some(_) = self.max_multicast_solicitations {
5513                return 1;
5514            }
5515            0
5516        }
5517    }
5518
5519    impl fidl::encoding::ValueTypeMarker for NudConfiguration {
5520        type Borrowed<'a> = &'a Self;
5521        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5522            value
5523        }
5524    }
5525
5526    unsafe impl fidl::encoding::TypeMarker for NudConfiguration {
5527        type Owned = Self;
5528
5529        #[inline(always)]
5530        fn inline_align(_context: fidl::encoding::Context) -> usize {
5531            8
5532        }
5533
5534        #[inline(always)]
5535        fn inline_size(_context: fidl::encoding::Context) -> usize {
5536            16
5537        }
5538    }
5539
5540    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NudConfiguration, D>
5541        for &NudConfiguration
5542    {
5543        unsafe fn encode(
5544            self,
5545            encoder: &mut fidl::encoding::Encoder<'_, D>,
5546            offset: usize,
5547            mut depth: fidl::encoding::Depth,
5548        ) -> fidl::Result<()> {
5549            encoder.debug_check_bounds::<NudConfiguration>(offset);
5550            // Vector header
5551            let max_ordinal: u64 = self.max_ordinal_present();
5552            encoder.write_num(max_ordinal, offset);
5553            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5554            // Calling encoder.out_of_line_offset(0) is not allowed.
5555            if max_ordinal == 0 {
5556                return Ok(());
5557            }
5558            depth.increment()?;
5559            let envelope_size = 8;
5560            let bytes_len = max_ordinal as usize * envelope_size;
5561            #[allow(unused_variables)]
5562            let offset = encoder.out_of_line_offset(bytes_len);
5563            let mut _prev_end_offset: usize = 0;
5564            if 1 > max_ordinal {
5565                return Ok(());
5566            }
5567
5568            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5569            // are envelope_size bytes.
5570            let cur_offset: usize = (1 - 1) * envelope_size;
5571
5572            // Zero reserved fields.
5573            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5574
5575            // Safety:
5576            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5577            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5578            //   envelope_size bytes, there is always sufficient room.
5579            fidl::encoding::encode_in_envelope_optional::<u16, D>(
5580                self.max_multicast_solicitations
5581                    .as_ref()
5582                    .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5583                encoder,
5584                offset + cur_offset,
5585                depth,
5586            )?;
5587
5588            _prev_end_offset = cur_offset + envelope_size;
5589            if 2 > max_ordinal {
5590                return Ok(());
5591            }
5592
5593            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5594            // are envelope_size bytes.
5595            let cur_offset: usize = (2 - 1) * envelope_size;
5596
5597            // Zero reserved fields.
5598            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5599
5600            // Safety:
5601            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5602            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5603            //   envelope_size bytes, there is always sufficient room.
5604            fidl::encoding::encode_in_envelope_optional::<u16, D>(
5605                self.max_unicast_solicitations
5606                    .as_ref()
5607                    .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
5608                encoder,
5609                offset + cur_offset,
5610                depth,
5611            )?;
5612
5613            _prev_end_offset = cur_offset + envelope_size;
5614            if 3 > max_ordinal {
5615                return Ok(());
5616            }
5617
5618            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5619            // are envelope_size bytes.
5620            let cur_offset: usize = (3 - 1) * envelope_size;
5621
5622            // Zero reserved fields.
5623            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5624
5625            // Safety:
5626            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5627            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5628            //   envelope_size bytes, there is always sufficient room.
5629            fidl::encoding::encode_in_envelope_optional::<i64, D>(
5630                self.base_reachable_time
5631                    .as_ref()
5632                    .map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
5633                encoder,
5634                offset + cur_offset,
5635                depth,
5636            )?;
5637
5638            _prev_end_offset = cur_offset + envelope_size;
5639
5640            Ok(())
5641        }
5642    }
5643
5644    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NudConfiguration {
5645        #[inline(always)]
5646        fn new_empty() -> Self {
5647            Self::default()
5648        }
5649
5650        unsafe fn decode(
5651            &mut self,
5652            decoder: &mut fidl::encoding::Decoder<'_, D>,
5653            offset: usize,
5654            mut depth: fidl::encoding::Depth,
5655        ) -> fidl::Result<()> {
5656            decoder.debug_check_bounds::<Self>(offset);
5657            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5658                None => return Err(fidl::Error::NotNullable),
5659                Some(len) => len,
5660            };
5661            // Calling decoder.out_of_line_offset(0) is not allowed.
5662            if len == 0 {
5663                return Ok(());
5664            };
5665            depth.increment()?;
5666            let envelope_size = 8;
5667            let bytes_len = len * envelope_size;
5668            let offset = decoder.out_of_line_offset(bytes_len)?;
5669            // Decode the envelope for each type.
5670            let mut _next_ordinal_to_read = 0;
5671            let mut next_offset = offset;
5672            let end_offset = offset + bytes_len;
5673            _next_ordinal_to_read += 1;
5674            if next_offset >= end_offset {
5675                return Ok(());
5676            }
5677
5678            // Decode unknown envelopes for gaps in ordinals.
5679            while _next_ordinal_to_read < 1 {
5680                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5681                _next_ordinal_to_read += 1;
5682                next_offset += envelope_size;
5683            }
5684
5685            let next_out_of_line = decoder.next_out_of_line();
5686            let handles_before = decoder.remaining_handles();
5687            if let Some((inlined, num_bytes, num_handles)) =
5688                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5689            {
5690                let member_inline_size =
5691                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5692                if inlined != (member_inline_size <= 4) {
5693                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5694                }
5695                let inner_offset;
5696                let mut inner_depth = depth.clone();
5697                if inlined {
5698                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5699                    inner_offset = next_offset;
5700                } else {
5701                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5702                    inner_depth.increment()?;
5703                }
5704                let val_ref = self
5705                    .max_multicast_solicitations
5706                    .get_or_insert_with(|| fidl::new_empty!(u16, D));
5707                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5708                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5709                {
5710                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5711                }
5712                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5713                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5714                }
5715            }
5716
5717            next_offset += envelope_size;
5718            _next_ordinal_to_read += 1;
5719            if next_offset >= end_offset {
5720                return Ok(());
5721            }
5722
5723            // Decode unknown envelopes for gaps in ordinals.
5724            while _next_ordinal_to_read < 2 {
5725                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5726                _next_ordinal_to_read += 1;
5727                next_offset += envelope_size;
5728            }
5729
5730            let next_out_of_line = decoder.next_out_of_line();
5731            let handles_before = decoder.remaining_handles();
5732            if let Some((inlined, num_bytes, num_handles)) =
5733                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5734            {
5735                let member_inline_size =
5736                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5737                if inlined != (member_inline_size <= 4) {
5738                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5739                }
5740                let inner_offset;
5741                let mut inner_depth = depth.clone();
5742                if inlined {
5743                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5744                    inner_offset = next_offset;
5745                } else {
5746                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5747                    inner_depth.increment()?;
5748                }
5749                let val_ref =
5750                    self.max_unicast_solicitations.get_or_insert_with(|| fidl::new_empty!(u16, D));
5751                fidl::decode!(u16, D, val_ref, decoder, inner_offset, inner_depth)?;
5752                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5753                {
5754                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5755                }
5756                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5757                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5758                }
5759            }
5760
5761            next_offset += envelope_size;
5762            _next_ordinal_to_read += 1;
5763            if next_offset >= end_offset {
5764                return Ok(());
5765            }
5766
5767            // Decode unknown envelopes for gaps in ordinals.
5768            while _next_ordinal_to_read < 3 {
5769                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5770                _next_ordinal_to_read += 1;
5771                next_offset += envelope_size;
5772            }
5773
5774            let next_out_of_line = decoder.next_out_of_line();
5775            let handles_before = decoder.remaining_handles();
5776            if let Some((inlined, num_bytes, num_handles)) =
5777                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5778            {
5779                let member_inline_size =
5780                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
5781                if inlined != (member_inline_size <= 4) {
5782                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5783                }
5784                let inner_offset;
5785                let mut inner_depth = depth.clone();
5786                if inlined {
5787                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5788                    inner_offset = next_offset;
5789                } else {
5790                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5791                    inner_depth.increment()?;
5792                }
5793                let val_ref =
5794                    self.base_reachable_time.get_or_insert_with(|| fidl::new_empty!(i64, D));
5795                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
5796                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
5797                {
5798                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
5799                }
5800                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5801                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5802                }
5803            }
5804
5805            next_offset += envelope_size;
5806
5807            // Decode the remaining unknown envelopes.
5808            while next_offset < end_offset {
5809                _next_ordinal_to_read += 1;
5810                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5811                next_offset += envelope_size;
5812            }
5813
5814            Ok(())
5815        }
5816    }
5817
5818    impl Options {
5819        #[inline(always)]
5820        fn max_ordinal_present(&self) -> u64 {
5821            if let Some(_) = self.metric {
5822                return 2;
5823            }
5824            if let Some(_) = self.name {
5825                return 1;
5826            }
5827            0
5828        }
5829    }
5830
5831    impl fidl::encoding::ValueTypeMarker for Options {
5832        type Borrowed<'a> = &'a Self;
5833        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5834            value
5835        }
5836    }
5837
5838    unsafe impl fidl::encoding::TypeMarker for Options {
5839        type Owned = Self;
5840
5841        #[inline(always)]
5842        fn inline_align(_context: fidl::encoding::Context) -> usize {
5843            8
5844        }
5845
5846        #[inline(always)]
5847        fn inline_size(_context: fidl::encoding::Context) -> usize {
5848            16
5849        }
5850    }
5851
5852    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Options, D> for &Options {
5853        unsafe fn encode(
5854            self,
5855            encoder: &mut fidl::encoding::Encoder<'_, D>,
5856            offset: usize,
5857            mut depth: fidl::encoding::Depth,
5858        ) -> fidl::Result<()> {
5859            encoder.debug_check_bounds::<Options>(offset);
5860            // Vector header
5861            let max_ordinal: u64 = self.max_ordinal_present();
5862            encoder.write_num(max_ordinal, offset);
5863            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
5864            // Calling encoder.out_of_line_offset(0) is not allowed.
5865            if max_ordinal == 0 {
5866                return Ok(());
5867            }
5868            depth.increment()?;
5869            let envelope_size = 8;
5870            let bytes_len = max_ordinal as usize * envelope_size;
5871            #[allow(unused_variables)]
5872            let offset = encoder.out_of_line_offset(bytes_len);
5873            let mut _prev_end_offset: usize = 0;
5874            if 1 > max_ordinal {
5875                return Ok(());
5876            }
5877
5878            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5879            // are envelope_size bytes.
5880            let cur_offset: usize = (1 - 1) * envelope_size;
5881
5882            // Zero reserved fields.
5883            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5884
5885            // Safety:
5886            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5887            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5888            //   envelope_size bytes, there is always sufficient room.
5889            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<15>, D>(
5890                self.name.as_ref().map(
5891                    <fidl::encoding::BoundedString<15> as fidl::encoding::ValueTypeMarker>::borrow,
5892                ),
5893                encoder,
5894                offset + cur_offset,
5895                depth,
5896            )?;
5897
5898            _prev_end_offset = cur_offset + envelope_size;
5899            if 2 > max_ordinal {
5900                return Ok(());
5901            }
5902
5903            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
5904            // are envelope_size bytes.
5905            let cur_offset: usize = (2 - 1) * envelope_size;
5906
5907            // Zero reserved fields.
5908            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
5909
5910            // Safety:
5911            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
5912            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
5913            //   envelope_size bytes, there is always sufficient room.
5914            fidl::encoding::encode_in_envelope_optional::<u32, D>(
5915                self.metric.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
5916                encoder,
5917                offset + cur_offset,
5918                depth,
5919            )?;
5920
5921            _prev_end_offset = cur_offset + envelope_size;
5922
5923            Ok(())
5924        }
5925    }
5926
5927    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Options {
5928        #[inline(always)]
5929        fn new_empty() -> Self {
5930            Self::default()
5931        }
5932
5933        unsafe fn decode(
5934            &mut self,
5935            decoder: &mut fidl::encoding::Decoder<'_, D>,
5936            offset: usize,
5937            mut depth: fidl::encoding::Depth,
5938        ) -> fidl::Result<()> {
5939            decoder.debug_check_bounds::<Self>(offset);
5940            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
5941                None => return Err(fidl::Error::NotNullable),
5942                Some(len) => len,
5943            };
5944            // Calling decoder.out_of_line_offset(0) is not allowed.
5945            if len == 0 {
5946                return Ok(());
5947            };
5948            depth.increment()?;
5949            let envelope_size = 8;
5950            let bytes_len = len * envelope_size;
5951            let offset = decoder.out_of_line_offset(bytes_len)?;
5952            // Decode the envelope for each type.
5953            let mut _next_ordinal_to_read = 0;
5954            let mut next_offset = offset;
5955            let end_offset = offset + bytes_len;
5956            _next_ordinal_to_read += 1;
5957            if next_offset >= end_offset {
5958                return Ok(());
5959            }
5960
5961            // Decode unknown envelopes for gaps in ordinals.
5962            while _next_ordinal_to_read < 1 {
5963                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
5964                _next_ordinal_to_read += 1;
5965                next_offset += envelope_size;
5966            }
5967
5968            let next_out_of_line = decoder.next_out_of_line();
5969            let handles_before = decoder.remaining_handles();
5970            if let Some((inlined, num_bytes, num_handles)) =
5971                fidl::encoding::decode_envelope_header(decoder, next_offset)?
5972            {
5973                let member_inline_size =
5974                    <fidl::encoding::BoundedString<15> as fidl::encoding::TypeMarker>::inline_size(
5975                        decoder.context,
5976                    );
5977                if inlined != (member_inline_size <= 4) {
5978                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
5979                }
5980                let inner_offset;
5981                let mut inner_depth = depth.clone();
5982                if inlined {
5983                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
5984                    inner_offset = next_offset;
5985                } else {
5986                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5987                    inner_depth.increment()?;
5988                }
5989                let val_ref = self
5990                    .name
5991                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<15>, D));
5992                fidl::decode!(
5993                    fidl::encoding::BoundedString<15>,
5994                    D,
5995                    val_ref,
5996                    decoder,
5997                    inner_offset,
5998                    inner_depth
5999                )?;
6000                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6001                {
6002                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6003                }
6004                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6005                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6006                }
6007            }
6008
6009            next_offset += envelope_size;
6010            _next_ordinal_to_read += 1;
6011            if next_offset >= end_offset {
6012                return Ok(());
6013            }
6014
6015            // Decode unknown envelopes for gaps in ordinals.
6016            while _next_ordinal_to_read < 2 {
6017                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6018                _next_ordinal_to_read += 1;
6019                next_offset += envelope_size;
6020            }
6021
6022            let next_out_of_line = decoder.next_out_of_line();
6023            let handles_before = decoder.remaining_handles();
6024            if let Some((inlined, num_bytes, num_handles)) =
6025                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6026            {
6027                let member_inline_size =
6028                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6029                if inlined != (member_inline_size <= 4) {
6030                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6031                }
6032                let inner_offset;
6033                let mut inner_depth = depth.clone();
6034                if inlined {
6035                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6036                    inner_offset = next_offset;
6037                } else {
6038                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6039                    inner_depth.increment()?;
6040                }
6041                let val_ref = self.metric.get_or_insert_with(|| fidl::new_empty!(u32, D));
6042                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
6043                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6044                {
6045                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6046                }
6047                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6048                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6049                }
6050            }
6051
6052            next_offset += envelope_size;
6053
6054            // Decode the remaining unknown envelopes.
6055            while next_offset < end_offset {
6056                _next_ordinal_to_read += 1;
6057                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6058                next_offset += envelope_size;
6059            }
6060
6061            Ok(())
6062        }
6063    }
6064
6065    impl SlaacConfiguration {
6066        #[inline(always)]
6067        fn max_ordinal_present(&self) -> u64 {
6068            if let Some(_) = self.temporary_address {
6069                return 1;
6070            }
6071            0
6072        }
6073    }
6074
6075    impl fidl::encoding::ValueTypeMarker for SlaacConfiguration {
6076        type Borrowed<'a> = &'a Self;
6077        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
6078            value
6079        }
6080    }
6081
6082    unsafe impl fidl::encoding::TypeMarker for SlaacConfiguration {
6083        type Owned = Self;
6084
6085        #[inline(always)]
6086        fn inline_align(_context: fidl::encoding::Context) -> usize {
6087            8
6088        }
6089
6090        #[inline(always)]
6091        fn inline_size(_context: fidl::encoding::Context) -> usize {
6092            16
6093        }
6094    }
6095
6096    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<SlaacConfiguration, D>
6097        for &SlaacConfiguration
6098    {
6099        unsafe fn encode(
6100            self,
6101            encoder: &mut fidl::encoding::Encoder<'_, D>,
6102            offset: usize,
6103            mut depth: fidl::encoding::Depth,
6104        ) -> fidl::Result<()> {
6105            encoder.debug_check_bounds::<SlaacConfiguration>(offset);
6106            // Vector header
6107            let max_ordinal: u64 = self.max_ordinal_present();
6108            encoder.write_num(max_ordinal, offset);
6109            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
6110            // Calling encoder.out_of_line_offset(0) is not allowed.
6111            if max_ordinal == 0 {
6112                return Ok(());
6113            }
6114            depth.increment()?;
6115            let envelope_size = 8;
6116            let bytes_len = max_ordinal as usize * envelope_size;
6117            #[allow(unused_variables)]
6118            let offset = encoder.out_of_line_offset(bytes_len);
6119            let mut _prev_end_offset: usize = 0;
6120            if 1 > max_ordinal {
6121                return Ok(());
6122            }
6123
6124            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
6125            // are envelope_size bytes.
6126            let cur_offset: usize = (1 - 1) * envelope_size;
6127
6128            // Zero reserved fields.
6129            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
6130
6131            // Safety:
6132            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
6133            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
6134            //   envelope_size bytes, there is always sufficient room.
6135            fidl::encoding::encode_in_envelope_optional::<bool, D>(
6136                self.temporary_address
6137                    .as_ref()
6138                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
6139                encoder,
6140                offset + cur_offset,
6141                depth,
6142            )?;
6143
6144            _prev_end_offset = cur_offset + envelope_size;
6145
6146            Ok(())
6147        }
6148    }
6149
6150    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SlaacConfiguration {
6151        #[inline(always)]
6152        fn new_empty() -> Self {
6153            Self::default()
6154        }
6155
6156        unsafe fn decode(
6157            &mut self,
6158            decoder: &mut fidl::encoding::Decoder<'_, D>,
6159            offset: usize,
6160            mut depth: fidl::encoding::Depth,
6161        ) -> fidl::Result<()> {
6162            decoder.debug_check_bounds::<Self>(offset);
6163            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
6164                None => return Err(fidl::Error::NotNullable),
6165                Some(len) => len,
6166            };
6167            // Calling decoder.out_of_line_offset(0) is not allowed.
6168            if len == 0 {
6169                return Ok(());
6170            };
6171            depth.increment()?;
6172            let envelope_size = 8;
6173            let bytes_len = len * envelope_size;
6174            let offset = decoder.out_of_line_offset(bytes_len)?;
6175            // Decode the envelope for each type.
6176            let mut _next_ordinal_to_read = 0;
6177            let mut next_offset = offset;
6178            let end_offset = offset + bytes_len;
6179            _next_ordinal_to_read += 1;
6180            if next_offset >= end_offset {
6181                return Ok(());
6182            }
6183
6184            // Decode unknown envelopes for gaps in ordinals.
6185            while _next_ordinal_to_read < 1 {
6186                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6187                _next_ordinal_to_read += 1;
6188                next_offset += envelope_size;
6189            }
6190
6191            let next_out_of_line = decoder.next_out_of_line();
6192            let handles_before = decoder.remaining_handles();
6193            if let Some((inlined, num_bytes, num_handles)) =
6194                fidl::encoding::decode_envelope_header(decoder, next_offset)?
6195            {
6196                let member_inline_size =
6197                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
6198                if inlined != (member_inline_size <= 4) {
6199                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
6200                }
6201                let inner_offset;
6202                let mut inner_depth = depth.clone();
6203                if inlined {
6204                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
6205                    inner_offset = next_offset;
6206                } else {
6207                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
6208                    inner_depth.increment()?;
6209                }
6210                let val_ref =
6211                    self.temporary_address.get_or_insert_with(|| fidl::new_empty!(bool, D));
6212                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
6213                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
6214                {
6215                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
6216                }
6217                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
6218                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
6219                }
6220            }
6221
6222            next_offset += envelope_size;
6223
6224            // Decode the remaining unknown envelopes.
6225            while next_offset < end_offset {
6226                _next_ordinal_to_read += 1;
6227                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
6228                next_offset += envelope_size;
6229            }
6230
6231            Ok(())
6232        }
6233    }
6234}