fidl_fuchsia_net_dhcp__common/
fidl_fuchsia_net_dhcp__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/// A DHCP option field of IP addresses.
12///
13/// Per https://tools.ietf.org/html/rfc2132#section-2:
14///
15///   All other options are variable-length with a length octet following the tag octet.
16///
17/// The maximum length is given by 0xFF/sizeof([`fuchsia.net.Ipv4Address`]).
18pub type Addresses = Vec<fidl_fuchsia_net__common::Ipv4Address>;
19
20/// A DHCP option field of ASCII characters.
21///
22/// Per https://tools.ietf.org/html/rfc2132#section-2:
23///
24///   All other options are variable-length with a length octet following the tag octet.
25///
26/// Valid iff it consists of characters from the ASCII character set.
27pub type AsciiString = String;
28
29/// A DHCP duration value, in seconds. As specified in
30/// https://tools.ietf.org/html/rfc2131#section-3.3, DHCP duration values are
31/// relative times.
32pub type Duration = u32;
33
34/// The maximum possible number of DNS servers that can be included in an
35/// acquired DHCP configuration.
36///
37/// According to [RFC 2132 section
38/// 3.8](https://www.rfc-editor.org/rfc/rfc2132#section-3.8), the length of the
39/// DNS server list in bytes is represented in the protocol by an 8-bit unsigned
40/// integer:
41/// "[variable-length options have] a length octet following the tag octet. The
42/// value of the length octet does not include the two octets specifying the tag
43/// and length."
44/// 2^8 = 256, which divided by 4 bytes gives us 64 as an upper bound on the
45/// maximum possible number of DNS servers that can be included in an acquired
46/// DHCP configuration.
47pub const MAX_DNS_SERVERS: u8 = 64;
48
49/// The maximum possible number of routers that can be included in an acquired
50/// DHCP configuration.
51///
52/// According to [RFC 2132 section
53/// 3.5](https://www.rfc-editor.org/rfc/rfc2132#section-3.5), the length of the
54/// routers list in bytes is represented in the protocol by an 8-bit unsigned
55/// integer:
56/// "[variable-length options have] a length octet following the tag octet. The
57/// value of the length octet does not include the two octets specifying the
58/// tag and length."
59/// 2^8 = 256, which divided by 4 bytes gives us 64 as an upper bound on the
60/// maximum possible number of routers that can be included in an acquired
61/// DHCP configuration.
62pub const MAX_ROUTERS: u8 = 64;
63
64bitflags! {
65    /// A NetBIOS over TCP/IP node type as defined in RFC 1001/1002. This bitflag is for use with the
66    /// NetBiosOverTcpipNodeType option.
67    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
68    pub struct NodeTypes: u8 {
69        /// A B node type.
70        const B_NODE = 1;
71        /// A P node type.
72        const P_NODE = 2;
73        /// A M node type.
74        const M_NODE = 4;
75        /// A H node type.
76        const H_NODE = 8;
77    }
78}
79
80impl NodeTypes {}
81
82#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
83#[repr(u32)]
84pub enum ClientExitReason {
85    /// A client already exists on the interface.
86    ClientAlreadyExistsOnInterface = 1,
87    /// More than one concurrent call to `WatchConfiguration` was made.
88    WatchConfigurationAlreadyPending = 2,
89    /// The interface identified is invalid for acquiring configuration.
90    InvalidInterface = 3,
91    /// Invalid `NewClientParams` were provided.
92    InvalidParams = 4,
93    /// The network was, or became, unreachable over the interface
94    /// provided to the DHCP client.
95    NetworkUnreachable = 5,
96    /// The client was unable to open a socket.
97    UnableToOpenSocket = 6,
98    /// Graceful shutdown was performed.
99    GracefulShutdown = 7,
100    /// An address acquired by this client was removed by a user.
101    AddressRemovedByUser = 8,
102    /// The `AddressStateProvider` for an address acquired by this
103    /// client exited with an error (or without providing a reason for
104    /// the address removal).
105    AddressStateProviderError = 9,
106}
107
108impl ClientExitReason {
109    #[inline]
110    pub fn from_primitive(prim: u32) -> Option<Self> {
111        match prim {
112            1 => Some(Self::ClientAlreadyExistsOnInterface),
113            2 => Some(Self::WatchConfigurationAlreadyPending),
114            3 => Some(Self::InvalidInterface),
115            4 => Some(Self::InvalidParams),
116            5 => Some(Self::NetworkUnreachable),
117            6 => Some(Self::UnableToOpenSocket),
118            7 => Some(Self::GracefulShutdown),
119            8 => Some(Self::AddressRemovedByUser),
120            9 => Some(Self::AddressStateProviderError),
121            _ => None,
122        }
123    }
124
125    #[inline]
126    pub const fn into_primitive(self) -> u32 {
127        self as u32
128    }
129}
130
131/// The type of DHCP message. The DHCP protocol requires that all messages identify
132/// their type by including the MessageType option. These values are specified
133/// in https://tools.ietf.org/html/rfc2132#section-9.6.
134#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
135#[repr(u8)]
136pub enum MessageType {
137    /// A DHCP Discover message.
138    Dhcpdiscover = 1,
139    /// A DHCP Offer message.
140    Dhcpoffer = 2,
141    /// A DHCP Request message.
142    Dhcprequest = 3,
143    /// A DHCP Decline message.
144    Dhcpdecline = 4,
145    /// A DHCP Ack message.
146    Dhcpack = 5,
147    /// A DHCP Nak message;
148    Dhcpnak = 6,
149    /// A DHCP Release message;
150    Dhcprelease = 7,
151    /// A DHCP Inform message.
152    Dhcpinform = 8,
153}
154
155impl MessageType {
156    #[inline]
157    pub fn from_primitive(prim: u8) -> Option<Self> {
158        match prim {
159            1 => Some(Self::Dhcpdiscover),
160            2 => Some(Self::Dhcpoffer),
161            3 => Some(Self::Dhcprequest),
162            4 => Some(Self::Dhcpdecline),
163            5 => Some(Self::Dhcpack),
164            6 => Some(Self::Dhcpnak),
165            7 => Some(Self::Dhcprelease),
166            8 => Some(Self::Dhcpinform),
167            _ => None,
168        }
169    }
170
171    #[inline]
172    pub const fn into_primitive(self) -> u8 {
173        self as u8
174    }
175}
176
177/// The code of a DHCP option to be retrieved by Server.GetOption(). The code
178/// values are from https://tools.ietf.org/html/rfc2132 and the enum variants
179/// have been listed in the order they are presented in the RFC.
180#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
181#[repr(u32)]
182pub enum OptionCode {
183    SubnetMask = 1,
184    TimeOffset = 2,
185    Router = 3,
186    TimeServer = 4,
187    NameServer = 5,
188    DomainNameServer = 6,
189    LogServer = 7,
190    CookieServer = 8,
191    LprServer = 9,
192    ImpressServer = 10,
193    ResourceLocationServer = 11,
194    HostName = 12,
195    BootFileSize = 13,
196    MeritDumpFile = 14,
197    DomainName = 15,
198    SwapServer = 16,
199    RootPath = 17,
200    ExtensionsPath = 18,
201    IpForwarding = 19,
202    NonLocalSourceRouting = 20,
203    PolicyFilter = 21,
204    MaxDatagramReassemblySize = 22,
205    DefaultIpTtl = 23,
206    PathMtuAgingTimeout = 24,
207    PathMtuPlateauTable = 25,
208    InterfaceMtu = 26,
209    AllSubnetsLocal = 27,
210    BroadcastAddress = 28,
211    PerformMaskDiscovery = 29,
212    MaskSupplier = 30,
213    PerformRouterDiscovery = 31,
214    RouterSolicitationAddress = 32,
215    StaticRoute = 33,
216    TrailerEncapsulation = 34,
217    ArpCacheTimeout = 35,
218    EthernetEncapsulation = 36,
219    TcpDefaultTtl = 37,
220    TcpKeepaliveInterval = 38,
221    TcpKeepaliveGarbage = 39,
222    NetworkInformationServiceDomain = 40,
223    NetworkInformationServers = 41,
224    NetworkTimeProtocolServers = 42,
225    VendorSpecificInformation = 43,
226    NetbiosOverTcpipNameServer = 44,
227    NetbiosOverTcpipDatagramDistributionServer = 45,
228    NetbiosOverTcpipNodeType = 46,
229    NetbiosOverTcpipScope = 47,
230    XWindowSystemFontServer = 48,
231    XWindowSystemDisplayManager = 49,
232    NetworkInformationServicePlusDomain = 64,
233    NetworkInformationServicePlusServers = 65,
234    MobileIpHomeAgent = 68,
235    SmtpServer = 69,
236    Pop3Server = 70,
237    NntpServer = 71,
238    DefaultWwwServer = 72,
239    DefaultFingerServer = 73,
240    DefaultIrcServer = 74,
241    StreettalkServer = 75,
242    StreettalkDirectoryAssistanceServer = 76,
243    OptionOverload = 52,
244    TftpServerName = 66,
245    BootfileName = 67,
246    MaxDhcpMessageSize = 57,
247    RenewalTimeValue = 58,
248    RebindingTimeValue = 59,
249}
250
251impl OptionCode {
252    #[inline]
253    pub fn from_primitive(prim: u32) -> Option<Self> {
254        match prim {
255            1 => Some(Self::SubnetMask),
256            2 => Some(Self::TimeOffset),
257            3 => Some(Self::Router),
258            4 => Some(Self::TimeServer),
259            5 => Some(Self::NameServer),
260            6 => Some(Self::DomainNameServer),
261            7 => Some(Self::LogServer),
262            8 => Some(Self::CookieServer),
263            9 => Some(Self::LprServer),
264            10 => Some(Self::ImpressServer),
265            11 => Some(Self::ResourceLocationServer),
266            12 => Some(Self::HostName),
267            13 => Some(Self::BootFileSize),
268            14 => Some(Self::MeritDumpFile),
269            15 => Some(Self::DomainName),
270            16 => Some(Self::SwapServer),
271            17 => Some(Self::RootPath),
272            18 => Some(Self::ExtensionsPath),
273            19 => Some(Self::IpForwarding),
274            20 => Some(Self::NonLocalSourceRouting),
275            21 => Some(Self::PolicyFilter),
276            22 => Some(Self::MaxDatagramReassemblySize),
277            23 => Some(Self::DefaultIpTtl),
278            24 => Some(Self::PathMtuAgingTimeout),
279            25 => Some(Self::PathMtuPlateauTable),
280            26 => Some(Self::InterfaceMtu),
281            27 => Some(Self::AllSubnetsLocal),
282            28 => Some(Self::BroadcastAddress),
283            29 => Some(Self::PerformMaskDiscovery),
284            30 => Some(Self::MaskSupplier),
285            31 => Some(Self::PerformRouterDiscovery),
286            32 => Some(Self::RouterSolicitationAddress),
287            33 => Some(Self::StaticRoute),
288            34 => Some(Self::TrailerEncapsulation),
289            35 => Some(Self::ArpCacheTimeout),
290            36 => Some(Self::EthernetEncapsulation),
291            37 => Some(Self::TcpDefaultTtl),
292            38 => Some(Self::TcpKeepaliveInterval),
293            39 => Some(Self::TcpKeepaliveGarbage),
294            40 => Some(Self::NetworkInformationServiceDomain),
295            41 => Some(Self::NetworkInformationServers),
296            42 => Some(Self::NetworkTimeProtocolServers),
297            43 => Some(Self::VendorSpecificInformation),
298            44 => Some(Self::NetbiosOverTcpipNameServer),
299            45 => Some(Self::NetbiosOverTcpipDatagramDistributionServer),
300            46 => Some(Self::NetbiosOverTcpipNodeType),
301            47 => Some(Self::NetbiosOverTcpipScope),
302            48 => Some(Self::XWindowSystemFontServer),
303            49 => Some(Self::XWindowSystemDisplayManager),
304            64 => Some(Self::NetworkInformationServicePlusDomain),
305            65 => Some(Self::NetworkInformationServicePlusServers),
306            68 => Some(Self::MobileIpHomeAgent),
307            69 => Some(Self::SmtpServer),
308            70 => Some(Self::Pop3Server),
309            71 => Some(Self::NntpServer),
310            72 => Some(Self::DefaultWwwServer),
311            73 => Some(Self::DefaultFingerServer),
312            74 => Some(Self::DefaultIrcServer),
313            75 => Some(Self::StreettalkServer),
314            76 => Some(Self::StreettalkDirectoryAssistanceServer),
315            52 => Some(Self::OptionOverload),
316            66 => Some(Self::TftpServerName),
317            67 => Some(Self::BootfileName),
318            57 => Some(Self::MaxDhcpMessageSize),
319            58 => Some(Self::RenewalTimeValue),
320            59 => Some(Self::RebindingTimeValue),
321            _ => None,
322        }
323    }
324
325    #[inline]
326    pub const fn into_primitive(self) -> u32 {
327        self as u32
328    }
329}
330
331/// A indication of which DHCP message field should be used to store additional options.
332#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
333#[repr(u8)]
334pub enum OptionOverloadValue {
335    /// The file DHCP field.
336    File = 1,
337    /// The sname DHCP field.
338    Sname = 2,
339    /// Both file and sname DHCP fields.
340    Both = 3,
341}
342
343impl OptionOverloadValue {
344    #[inline]
345    pub fn from_primitive(prim: u8) -> Option<Self> {
346        match prim {
347            1 => Some(Self::File),
348            2 => Some(Self::Sname),
349            3 => Some(Self::Both),
350            _ => None,
351        }
352    }
353
354    #[inline]
355    pub const fn into_primitive(self) -> u8 {
356        self as u8
357    }
358}
359
360/// The name of the Parameter to be retrieved by Server.GetParameter().
361#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
362#[repr(u32)]
363pub enum ParameterName {
364    IpAddrs = 0,
365    AddressPool = 1,
366    LeaseLength = 2,
367    PermittedMacs = 3,
368    StaticallyAssignedAddrs = 4,
369    ArpProbe = 5,
370    BoundDeviceNames = 6,
371}
372
373impl ParameterName {
374    #[inline]
375    pub fn from_primitive(prim: u32) -> Option<Self> {
376        match prim {
377            0 => Some(Self::IpAddrs),
378            1 => Some(Self::AddressPool),
379            2 => Some(Self::LeaseLength),
380            3 => Some(Self::PermittedMacs),
381            4 => Some(Self::StaticallyAssignedAddrs),
382            5 => Some(Self::ArpProbe),
383            6 => Some(Self::BoundDeviceNames),
384            _ => None,
385        }
386    }
387
388    #[inline]
389    pub const fn into_primitive(self) -> u32 {
390        self as u32
391    }
392}
393
394#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
395pub struct ClientOnExitRequest {
396    pub reason: ClientExitReason,
397}
398
399impl fidl::Persistable for ClientOnExitRequest {}
400
401#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
402pub struct ServerGetOptionRequest {
403    pub code: OptionCode,
404}
405
406impl fidl::Persistable for ServerGetOptionRequest {}
407
408#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
409pub struct ServerGetParameterRequest {
410    pub name: ParameterName,
411}
412
413impl fidl::Persistable for ServerGetParameterRequest {}
414
415#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
416pub struct ServerIsServingResponse {
417    pub enabled: bool,
418}
419
420impl fidl::Persistable for ServerIsServingResponse {}
421
422#[derive(Clone, Debug, PartialEq)]
423pub struct ServerSetOptionRequest {
424    pub value: Option_,
425}
426
427impl fidl::Persistable for ServerSetOptionRequest {}
428
429#[derive(Clone, Debug, PartialEq)]
430pub struct ServerSetParameterRequest {
431    pub value: Parameter,
432}
433
434impl fidl::Persistable for ServerSetParameterRequest {}
435
436#[derive(Clone, Debug, PartialEq)]
437pub struct ServerGetOptionResponse {
438    pub value: Option_,
439}
440
441impl fidl::Persistable for ServerGetOptionResponse {}
442
443#[derive(Clone, Debug, PartialEq)]
444pub struct ServerGetParameterResponse {
445    pub value: Parameter,
446}
447
448impl fidl::Persistable for ServerGetParameterResponse {}
449
450#[derive(Clone, Debug, PartialEq)]
451pub struct ServerListOptionsResponse {
452    pub options: Vec<Option_>,
453}
454
455impl fidl::Persistable for ServerListOptionsResponse {}
456
457#[derive(Clone, Debug, PartialEq)]
458pub struct ServerListParametersResponse {
459    pub parameters: Vec<Parameter>,
460}
461
462impl fidl::Persistable for ServerListParametersResponse {}
463
464#[derive(Clone, Debug, Default, PartialEq)]
465pub struct AddressPool {
466    /// The prefix length (in bits) of the address pool's subnet mask.
467    pub prefix_length: Option<u8>,
468    /// The starting address, inclusive, of the range of addresses which the
469    /// DHCP server will lease to clients.
470    pub range_start: Option<fidl_fuchsia_net__common::Ipv4Address>,
471    /// The ending address, exclusive, of the range of addresses which the
472    /// server will lease to clients.
473    pub range_stop: Option<fidl_fuchsia_net__common::Ipv4Address>,
474    #[doc(hidden)]
475    pub __source_breaking: fidl::marker::SourceBreaking,
476}
477
478impl fidl::Persistable for AddressPool {}
479
480/// Describes the configuration information the DHCP client requests from DHCP
481/// servers.
482#[derive(Clone, Debug, Default, PartialEq)]
483pub struct ConfigurationToRequest {
484    /// Request a list of IP addresses for routers on the client's subnet,
485    /// in order of preference.
486    /// See [RFC 2132 section 3.5](https://www.rfc-editor.org/rfc/rfc2132#section-3.5).
487    ///
488    /// If not set, interpreted as false.
489    pub routers: Option<bool>,
490    /// Request a list of available DNS servers.
491    /// See [RFC 2132 section 3.8](https://www.rfc-editor.org/rfc/rfc2132#section-3.8).
492    ///
493    /// If not set, interpreted as false.
494    pub dns_servers: Option<bool>,
495    #[doc(hidden)]
496    pub __source_breaking: fidl::marker::SourceBreaking,
497}
498
499impl fidl::Persistable for ConfigurationToRequest {}
500
501#[derive(Clone, Debug, Default, PartialEq)]
502pub struct LeaseLength {
503    /// The default lease length to be issued to clients. This field must
504    /// have a value.
505    pub default: Option<u32>,
506    /// The maximum lease length value which the server will issue to
507    /// clients who have requested a specific lease length. If omitted, the
508    /// max lease length is equivalent to the default lease length.
509    pub max: Option<u32>,
510    #[doc(hidden)]
511    pub __source_breaking: fidl::marker::SourceBreaking,
512}
513
514impl fidl::Persistable for LeaseLength {}
515
516#[derive(Clone, Debug, Default, PartialEq)]
517pub struct NewClientParams {
518    /// Parameters for describing the configuration information the DHCP
519    /// client requests from DHCP servers.
520    ///
521    /// If not set, interpreted as empty (no configuration information
522    /// is requested).
523    pub configuration_to_request: Option<ConfigurationToRequest>,
524    /// Whether the client negotiates an IP address.
525    ///
526    /// If false or not set, the client asks only for local
527    /// configuration parameters.
528    /// See [RFC 2131 section 3.4](https://www.rfc-editor.org/rfc/rfc2131#section-3.4).
529    pub request_ip_address: Option<bool>,
530    #[doc(hidden)]
531    pub __source_breaking: fidl::marker::SourceBreaking,
532}
533
534impl fidl::Persistable for NewClientParams {}
535
536#[derive(Clone, Debug, Default, PartialEq)]
537pub struct StaticAssignment {
538    /// The MAC address of the host or device which will have the static IP
539    /// address assignment.
540    pub host: Option<fidl_fuchsia_net__common::MacAddress>,
541    /// The IP address which the host or device will always be assigned the
542    /// server.
543    pub assigned_addr: Option<fidl_fuchsia_net__common::Ipv4Address>,
544    #[doc(hidden)]
545    pub __source_breaking: fidl::marker::SourceBreaking,
546}
547
548impl fidl::Persistable for StaticAssignment {}
549
550/// A generic representation of client configuration parameters and DHCP settings. Options are the
551/// mechanism by which the DHCP protocol communicates configuration parameters from a repository on
552/// a DHCP server to DHCP clients, or by which DHCP clients and servers communicate data relevant to
553/// a DHCP transaction.
554/// All DHCP option values must have a length which can fit within a single byte, i.e. less than 256.
555/// Options for which there is no reasonable administrator-configurable value have been omitted
556/// from this xunion. The omitted options are:
557/// * Pad - never has a value
558/// * End - never has a value
559/// * RequestedIpAddress - value always selected by the DHCP client.
560/// * DhcpMessageType - value always determined by state of transaction between DHCP client and server.
561/// * ServerIdentifier - value always determined by address to which the server is bound.
562/// * ParameterRequestList - value always selected by the DHCP client.
563/// * Message - value determined in response to runtime error.
564/// * VendorClassIdentifer - value always selected by the DHCP client.
565/// * ClientIdentifier - value always selected by the DHCP client.
566#[derive(Clone, Debug)]
567pub enum Option_ {
568    /// A 32-bit IPv4 subnet mask.
569    SubnetMask(fidl_fuchsia_net__common::Ipv4Address),
570    /// The client's offset from UTC in seconds. A positive offset is east of the zero meridian, and
571    /// a negative offset is west of the zero meridian.
572    TimeOffset(i32),
573    /// A list of the routers in a client's subnet, listed in order of preference.
574    Router(Vec<fidl_fuchsia_net__common::Ipv4Address>),
575    /// A list of time servers available to the client, in order of preference.
576    TimeServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
577    /// A list of IEN 116 Name servers available to the client, in order of preference.
578    NameServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
579    /// A list of Domain Name System servers available to the client, in order of preference;
580    DomainNameServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
581    /// A list of MIT-LCS UDP Log servers available to the client, in order of preference.
582    LogServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
583    /// A list of RFC 865 Cookie servers available to the client, in order of preference.
584    CookieServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
585    /// A list of RFC 1179 Line Printer servers available to the client, in order of preference.
586    LprServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
587    /// A list of Imagen Impress servers available to the client, in order of preference.
588    ImpressServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
589    /// A list of RFC 887 Resource Location servers available to the client, in order of preference.
590    ResourceLocationServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
591    /// The host name of the client, which may or may not be qualified with the local domain name.
592    HostName(String),
593    /// The size of the client's default boot image in 512-octet blocks.
594    BootFileSize(u16),
595    /// The path name to the client's core dump in the event the client crashes.
596    MeritDumpFile(String),
597    /// The client's domain name for use in resolving hostnames in the DNS.
598    DomainName(String),
599    /// The address of the client's swap server.
600    SwapServer(fidl_fuchsia_net__common::Ipv4Address),
601    /// The path name to the client's root disk.
602    RootPath(String),
603    /// The path name to a TFTP-retrievable file. This file contains data which can be interpreted
604    /// as the BOOTP vendor-extension field. Unlike the BOOTP vendor-extension field, this file has
605    /// an unconstrained length and any references to Tag 18 are ignored.
606    ExtensionsPath(String),
607    /// A flag which will enabled IP layer packet forwarding when true.
608    IpForwarding(bool),
609    /// A flag which will enable forwarding of IP packets with non-local source routes.
610    NonLocalSourceRouting(bool),
611    /// Policy filters for non-local source routing.
612    /// A list of IP Address and Subnet Mask pairs. If an incoming source-routed packet has a
613    /// next-hop that does not match one of these pairs, then the packet will be dropped.
614    PolicyFilter(Vec<fidl_fuchsia_net__common::Ipv4Address>),
615    /// The maximum sized datagram that the client should be able to reassemble, in octets. The
616    /// minimum legal value is 576.
617    MaxDatagramReassemblySize(u16),
618    /// The default time-to-live to use on outgoing IP datagrams. The value must be between 1 and
619    /// 255.
620    DefaultIpTtl(u8),
621    /// The timeout to be used when aging Path MTU values by the mechanism in RFC 1191.
622    PathMtuAgingTimeout(u32),
623    /// Table of MTU sizes for Path MTU Discovery.
624    /// A list of MTU sizes, ordered from smallest to largest. The smallest value cannot be smaller
625    /// than 68.
626    PathMtuPlateauTable(Vec<u16>),
627    /// The MTU for the client's interface. Minimum value of 68.
628    InterfaceMtu(u16),
629    /// A flag indicating if all subents of the IP network to which the client is connected have the
630    /// same MTU.
631    AllSubnetsLocal(bool),
632    /// The broadcast address of the client's subnet. Legal values are defined in RFC 1122.
633    BroadcastAddress(fidl_fuchsia_net__common::Ipv4Address),
634    /// A flag indicating whether the client should perform subnet mask discovery via ICMP.
635    PerformMaskDiscovery(bool),
636    /// A flag indicating whether the client should respond to subnet mask discovery requests via
637    /// ICMP.
638    MaskSupplier(bool),
639    /// A flag indicating whether the client should solicit routers using Router Discovery as
640    /// defined in RFC 1256.
641    PerformRouterDiscovery(bool),
642    /// The address to which the client should transmit Router Solicitation requests.
643    RouterSolicitationAddress(fidl_fuchsia_net__common::Ipv4Address),
644    /// Static Routes which the host should put in its routing cache.
645    /// A list of Destination address/Next-hop address pairs defining static routes for the client's
646    /// routing table. The routes should be listed in descending order of priority. It is illegal
647    /// to use 0.0.0.0 as the destination in a static route.
648    StaticRoute(Vec<fidl_fuchsia_net__common::Ipv4Address>),
649    /// A flag specifying whether the client negotiate the use of trailers when using ARP, per RFC
650    /// 893.
651    TrailerEncapsulation(bool),
652    /// The timeout for ARP cache entries.
653    ArpCacheTimeout(u32),
654    /// A flag specifying that the client should use Ethernet v2 encapsulation when false, and IEEE
655    /// 802.3 encapsulation when true.
656    EthernetEncapsulation(bool),
657    /// The default time-to-live that the client should use for outgoing TCP segments. The minimum
658    /// value is 1.
659    TcpDefaultTtl(u8),
660    /// The interval the client should wait before sending a TCP keepalive message. A
661    /// value of 0 indicates that the client should not send keepalive messages unless specifically
662    /// requested by an application.
663    TcpKeepaliveInterval(u32),
664    /// A flag specifying whether the client should send TCP keepalive messages with an octet of
665    /// garbage for compatibility with older implementations.
666    TcpKeepaliveGarbage(bool),
667    /// The name of the client's Network Information Service domain.
668    NetworkInformationServiceDomain(String),
669    /// A list of Network Information Service server addresses available to the client, listed in
670    /// order of preference.
671    NetworkInformationServers(Vec<fidl_fuchsia_net__common::Ipv4Address>),
672    /// A list of Network Time Protocol (NTP) server addresses available to the client, listed in
673    /// order of preference.
674    NetworkTimeProtocolServers(Vec<fidl_fuchsia_net__common::Ipv4Address>),
675    /// An opaque object of octets for exchanging vendor-specific information.
676    VendorSpecificInformation(Vec<u8>),
677    /// A list of NetBIOS name server addresses available to the client, listed in order of
678    /// preference.
679    NetbiosOverTcpipNameServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
680    /// A list of NetBIOS datagram distribution servers available to the client, listed in order of
681    /// preference.
682    NetbiosOverTcpipDatagramDistributionServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
683    /// The NetBIOS node type which should be used by the client.
684    NetbiosOverTcpipNodeType(NodeTypes),
685    /// The NetBIOS over TCP/IP scope parameter, as defined in RFC 1001, for the client.
686    NetbiosOverTcpipScope(String),
687    /// A list of X Window System Font server addresses available to the client, listed in order of
688    /// preference.
689    XWindowSystemFontServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
690    /// A list of X Window System Display Manager system addresses available to the client, listed
691    /// in order of preference.
692    XWindowSystemDisplayManager(Vec<fidl_fuchsia_net__common::Ipv4Address>),
693    /// The name of the client's Network Information System+ domain.
694    NetworkInformationServicePlusDomain(String),
695    /// A list of Network Information System+ server addresses available to the client, listed in
696    /// order of preference.
697    NetworkInformationServicePlusServers(Vec<fidl_fuchsia_net__common::Ipv4Address>),
698    /// A list of mobile IP home agent addresses available to the client, listed in order of
699    /// preference.
700    MobileIpHomeAgent(Vec<fidl_fuchsia_net__common::Ipv4Address>),
701    /// A list of Simple Mail Transport Protocol (SMTP) server address available to the client,
702    /// listed in order of preference.
703    SmtpServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
704    /// A list of Post Office Protocol (POP3) server addresses available to the client, listed in
705    /// order of preference.
706    Pop3Server(Vec<fidl_fuchsia_net__common::Ipv4Address>),
707    /// A list Network News Transport Protocol (NNTP) server addresses available to the client,
708    /// listed in order of preference.
709    NntpServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
710    /// A list of default World Wide Web (WWW) server addresses available to the client, listed in
711    /// order of preference.
712    DefaultWwwServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
713    /// A list of default Finger server addresses available to the client, listed in order of
714    /// preference.
715    DefaultFingerServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
716    /// A list of Internet Relay Chat server addresses available to the client, listed in order of
717    /// preference.
718    DefaultIrcServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
719    /// A list of StreetTalk server addresses available to the client, listed in order of
720    /// preference.
721    StreettalkServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
722    /// A list of StreetTalk Directory Assistance server addresses available to the client, listed
723    /// in order of preference.
724    StreettalkDirectoryAssistanceServer(Vec<fidl_fuchsia_net__common::Ipv4Address>),
725    /// An option specifying whether the `sname`, `file`, or both fields have been overloaded to
726    /// carry DHCP options. If this option is present, the client interprets the additional fields
727    /// after it concludes interpreting standard option fields.
728    OptionOverload(OptionOverloadValue),
729    /// The TFTP server name available to the client. This option should be used when the `sname`
730    /// field has been overloaded to carry options.
731    TftpServerName(String),
732    /// The bootfile name for the client. This option should be used when the `file` field has been
733    /// overloaded to carry options.
734    BootfileName(String),
735    /// The maximum length in octets of a DHCP message that the participant is willing to accept.
736    /// The minimum value is 576.
737    MaxDhcpMessageSize(u16),
738    /// The time interval after address assignment at which the client will transition
739    /// to the Renewing state.
740    RenewalTimeValue(u32),
741    /// The time interval after address assignment at which the client will transition
742    /// to the Rebinding state.
743    RebindingTimeValue(u32),
744    #[doc(hidden)]
745    __SourceBreaking { unknown_ordinal: u64 },
746}
747
748/// Pattern that matches an unknown `Option_` member.
749#[macro_export]
750macro_rules! Option_Unknown {
751    () => {
752        _
753    };
754}
755
756// Custom PartialEq so that unknown variants are not equal to themselves.
757impl PartialEq for Option_ {
758    fn eq(&self, other: &Self) -> bool {
759        match (self, other) {
760            (Self::SubnetMask(x), Self::SubnetMask(y)) => *x == *y,
761            (Self::TimeOffset(x), Self::TimeOffset(y)) => *x == *y,
762            (Self::Router(x), Self::Router(y)) => *x == *y,
763            (Self::TimeServer(x), Self::TimeServer(y)) => *x == *y,
764            (Self::NameServer(x), Self::NameServer(y)) => *x == *y,
765            (Self::DomainNameServer(x), Self::DomainNameServer(y)) => *x == *y,
766            (Self::LogServer(x), Self::LogServer(y)) => *x == *y,
767            (Self::CookieServer(x), Self::CookieServer(y)) => *x == *y,
768            (Self::LprServer(x), Self::LprServer(y)) => *x == *y,
769            (Self::ImpressServer(x), Self::ImpressServer(y)) => *x == *y,
770            (Self::ResourceLocationServer(x), Self::ResourceLocationServer(y)) => *x == *y,
771            (Self::HostName(x), Self::HostName(y)) => *x == *y,
772            (Self::BootFileSize(x), Self::BootFileSize(y)) => *x == *y,
773            (Self::MeritDumpFile(x), Self::MeritDumpFile(y)) => *x == *y,
774            (Self::DomainName(x), Self::DomainName(y)) => *x == *y,
775            (Self::SwapServer(x), Self::SwapServer(y)) => *x == *y,
776            (Self::RootPath(x), Self::RootPath(y)) => *x == *y,
777            (Self::ExtensionsPath(x), Self::ExtensionsPath(y)) => *x == *y,
778            (Self::IpForwarding(x), Self::IpForwarding(y)) => *x == *y,
779            (Self::NonLocalSourceRouting(x), Self::NonLocalSourceRouting(y)) => *x == *y,
780            (Self::PolicyFilter(x), Self::PolicyFilter(y)) => *x == *y,
781            (Self::MaxDatagramReassemblySize(x), Self::MaxDatagramReassemblySize(y)) => *x == *y,
782            (Self::DefaultIpTtl(x), Self::DefaultIpTtl(y)) => *x == *y,
783            (Self::PathMtuAgingTimeout(x), Self::PathMtuAgingTimeout(y)) => *x == *y,
784            (Self::PathMtuPlateauTable(x), Self::PathMtuPlateauTable(y)) => *x == *y,
785            (Self::InterfaceMtu(x), Self::InterfaceMtu(y)) => *x == *y,
786            (Self::AllSubnetsLocal(x), Self::AllSubnetsLocal(y)) => *x == *y,
787            (Self::BroadcastAddress(x), Self::BroadcastAddress(y)) => *x == *y,
788            (Self::PerformMaskDiscovery(x), Self::PerformMaskDiscovery(y)) => *x == *y,
789            (Self::MaskSupplier(x), Self::MaskSupplier(y)) => *x == *y,
790            (Self::PerformRouterDiscovery(x), Self::PerformRouterDiscovery(y)) => *x == *y,
791            (Self::RouterSolicitationAddress(x), Self::RouterSolicitationAddress(y)) => *x == *y,
792            (Self::StaticRoute(x), Self::StaticRoute(y)) => *x == *y,
793            (Self::TrailerEncapsulation(x), Self::TrailerEncapsulation(y)) => *x == *y,
794            (Self::ArpCacheTimeout(x), Self::ArpCacheTimeout(y)) => *x == *y,
795            (Self::EthernetEncapsulation(x), Self::EthernetEncapsulation(y)) => *x == *y,
796            (Self::TcpDefaultTtl(x), Self::TcpDefaultTtl(y)) => *x == *y,
797            (Self::TcpKeepaliveInterval(x), Self::TcpKeepaliveInterval(y)) => *x == *y,
798            (Self::TcpKeepaliveGarbage(x), Self::TcpKeepaliveGarbage(y)) => *x == *y,
799            (
800                Self::NetworkInformationServiceDomain(x),
801                Self::NetworkInformationServiceDomain(y),
802            ) => *x == *y,
803            (Self::NetworkInformationServers(x), Self::NetworkInformationServers(y)) => *x == *y,
804            (Self::NetworkTimeProtocolServers(x), Self::NetworkTimeProtocolServers(y)) => *x == *y,
805            (Self::VendorSpecificInformation(x), Self::VendorSpecificInformation(y)) => *x == *y,
806            (Self::NetbiosOverTcpipNameServer(x), Self::NetbiosOverTcpipNameServer(y)) => *x == *y,
807            (
808                Self::NetbiosOverTcpipDatagramDistributionServer(x),
809                Self::NetbiosOverTcpipDatagramDistributionServer(y),
810            ) => *x == *y,
811            (Self::NetbiosOverTcpipNodeType(x), Self::NetbiosOverTcpipNodeType(y)) => *x == *y,
812            (Self::NetbiosOverTcpipScope(x), Self::NetbiosOverTcpipScope(y)) => *x == *y,
813            (Self::XWindowSystemFontServer(x), Self::XWindowSystemFontServer(y)) => *x == *y,
814            (Self::XWindowSystemDisplayManager(x), Self::XWindowSystemDisplayManager(y)) => {
815                *x == *y
816            }
817            (
818                Self::NetworkInformationServicePlusDomain(x),
819                Self::NetworkInformationServicePlusDomain(y),
820            ) => *x == *y,
821            (
822                Self::NetworkInformationServicePlusServers(x),
823                Self::NetworkInformationServicePlusServers(y),
824            ) => *x == *y,
825            (Self::MobileIpHomeAgent(x), Self::MobileIpHomeAgent(y)) => *x == *y,
826            (Self::SmtpServer(x), Self::SmtpServer(y)) => *x == *y,
827            (Self::Pop3Server(x), Self::Pop3Server(y)) => *x == *y,
828            (Self::NntpServer(x), Self::NntpServer(y)) => *x == *y,
829            (Self::DefaultWwwServer(x), Self::DefaultWwwServer(y)) => *x == *y,
830            (Self::DefaultFingerServer(x), Self::DefaultFingerServer(y)) => *x == *y,
831            (Self::DefaultIrcServer(x), Self::DefaultIrcServer(y)) => *x == *y,
832            (Self::StreettalkServer(x), Self::StreettalkServer(y)) => *x == *y,
833            (
834                Self::StreettalkDirectoryAssistanceServer(x),
835                Self::StreettalkDirectoryAssistanceServer(y),
836            ) => *x == *y,
837            (Self::OptionOverload(x), Self::OptionOverload(y)) => *x == *y,
838            (Self::TftpServerName(x), Self::TftpServerName(y)) => *x == *y,
839            (Self::BootfileName(x), Self::BootfileName(y)) => *x == *y,
840            (Self::MaxDhcpMessageSize(x), Self::MaxDhcpMessageSize(y)) => *x == *y,
841            (Self::RenewalTimeValue(x), Self::RenewalTimeValue(y)) => *x == *y,
842            (Self::RebindingTimeValue(x), Self::RebindingTimeValue(y)) => *x == *y,
843            _ => false,
844        }
845    }
846}
847
848impl Option_ {
849    #[inline]
850    pub fn ordinal(&self) -> u64 {
851        match *self {
852            Self::SubnetMask(_) => 1,
853            Self::TimeOffset(_) => 2,
854            Self::Router(_) => 3,
855            Self::TimeServer(_) => 4,
856            Self::NameServer(_) => 5,
857            Self::DomainNameServer(_) => 6,
858            Self::LogServer(_) => 7,
859            Self::CookieServer(_) => 8,
860            Self::LprServer(_) => 9,
861            Self::ImpressServer(_) => 10,
862            Self::ResourceLocationServer(_) => 11,
863            Self::HostName(_) => 12,
864            Self::BootFileSize(_) => 13,
865            Self::MeritDumpFile(_) => 14,
866            Self::DomainName(_) => 15,
867            Self::SwapServer(_) => 16,
868            Self::RootPath(_) => 17,
869            Self::ExtensionsPath(_) => 18,
870            Self::IpForwarding(_) => 19,
871            Self::NonLocalSourceRouting(_) => 20,
872            Self::PolicyFilter(_) => 21,
873            Self::MaxDatagramReassemblySize(_) => 22,
874            Self::DefaultIpTtl(_) => 23,
875            Self::PathMtuAgingTimeout(_) => 24,
876            Self::PathMtuPlateauTable(_) => 25,
877            Self::InterfaceMtu(_) => 26,
878            Self::AllSubnetsLocal(_) => 27,
879            Self::BroadcastAddress(_) => 28,
880            Self::PerformMaskDiscovery(_) => 29,
881            Self::MaskSupplier(_) => 30,
882            Self::PerformRouterDiscovery(_) => 31,
883            Self::RouterSolicitationAddress(_) => 32,
884            Self::StaticRoute(_) => 33,
885            Self::TrailerEncapsulation(_) => 34,
886            Self::ArpCacheTimeout(_) => 35,
887            Self::EthernetEncapsulation(_) => 36,
888            Self::TcpDefaultTtl(_) => 37,
889            Self::TcpKeepaliveInterval(_) => 38,
890            Self::TcpKeepaliveGarbage(_) => 39,
891            Self::NetworkInformationServiceDomain(_) => 40,
892            Self::NetworkInformationServers(_) => 41,
893            Self::NetworkTimeProtocolServers(_) => 42,
894            Self::VendorSpecificInformation(_) => 43,
895            Self::NetbiosOverTcpipNameServer(_) => 44,
896            Self::NetbiosOverTcpipDatagramDistributionServer(_) => 45,
897            Self::NetbiosOverTcpipNodeType(_) => 46,
898            Self::NetbiosOverTcpipScope(_) => 47,
899            Self::XWindowSystemFontServer(_) => 48,
900            Self::XWindowSystemDisplayManager(_) => 49,
901            Self::NetworkInformationServicePlusDomain(_) => 50,
902            Self::NetworkInformationServicePlusServers(_) => 51,
903            Self::MobileIpHomeAgent(_) => 52,
904            Self::SmtpServer(_) => 53,
905            Self::Pop3Server(_) => 54,
906            Self::NntpServer(_) => 55,
907            Self::DefaultWwwServer(_) => 56,
908            Self::DefaultFingerServer(_) => 57,
909            Self::DefaultIrcServer(_) => 58,
910            Self::StreettalkServer(_) => 59,
911            Self::StreettalkDirectoryAssistanceServer(_) => 60,
912            Self::OptionOverload(_) => 61,
913            Self::TftpServerName(_) => 62,
914            Self::BootfileName(_) => 63,
915            Self::MaxDhcpMessageSize(_) => 64,
916            Self::RenewalTimeValue(_) => 65,
917            Self::RebindingTimeValue(_) => 66,
918            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
919        }
920    }
921
922    #[inline]
923    pub fn unknown_variant_for_testing() -> Self {
924        Self::__SourceBreaking { unknown_ordinal: 0 }
925    }
926
927    #[inline]
928    pub fn is_unknown(&self) -> bool {
929        match self {
930            Self::__SourceBreaking { .. } => true,
931            _ => false,
932        }
933    }
934}
935
936impl fidl::Persistable for Option_ {}
937
938/// The configurable server parameters.
939#[derive(Clone, Debug)]
940pub enum Parameter {
941    /// The IP addresses to which the server is bound. The vector bound has been
942    /// arbitrarily selected as a generous upper limit.
943    IpAddrs(Vec<fidl_fuchsia_net__common::Ipv4Address>),
944    /// The pool of addresses managed by a DHCP server and from which leases are
945    /// supplied.
946    ///
947    /// The pool is valid iff all of the following are true:
948    ///   1) All fields are present.
949    ///   2) The stop address is larger than the start address.
950    ///   3) The prefix length is large enough to fit the full range of
951    ///      addresses.
952    ///
953    /// For example, a pool of 4 addresses with a 24 bit subnet mask could be
954    /// specified as:
955    ///   {
956    ///     prefix_length: 24,
957    ///     range_start: 192.168.1.2,
958    ///     range_stop: 192.168.1.5,
959    ///   }
960    ///
961    /// Changing the address pool will not cancel existing leases because the
962    /// DHCP protocol does not provide a mechanism for doing so. Administrators
963    /// should take care when changing the address pool for a server with active
964    /// leases.
965    AddressPool(AddressPool),
966    /// The duration of leases offered by the server.
967    Lease(LeaseLength),
968    /// The client MAC addresses which the server will issue leases to. By
969    /// default, the server will not have a permitted MAC list, in which case it
970    /// will attempt to issue a lease to every client which requests one. If
971    /// permitted_macs has a non-zero length then the server will only respond
972    /// to lease requests from clients with  MAC in the list. The vector bound
973    /// has been arbitrarily selected as a generous upper limit.
974    PermittedMacs(Vec<fidl_fuchsia_net__common::MacAddress>),
975    /// Addresses statically assigned to specific hosts or devices. Typically, a
976    /// network administrator will statically assign addresses to always-on
977    /// network devices which should always have the same IP address, such as
978    /// network printers. The vector bound has been arbitrarily selected as a
979    /// generous upper limit.
980    StaticallyAssignedAddrs(Vec<StaticAssignment>),
981    /// Enables server behavior where the server ARPs an IP address prior to
982    /// issuing it in a lease. If the server receives a response, the server
983    /// will mark the address as in-use and try again with a different address.
984    ArpProbe(bool),
985    /// The names of the interface to which the server will listen. If this
986    /// vector is empty, the server will listen on all interfaces and will
987    /// process incoming DHCP messages regardless of the interface on which they
988    /// arrive. If this vector is not empty, then the server will only listen
989    /// for incoming DHCP messages on the named interfaces contained by this
990    /// vector. The string and vectors bounds have been arbitrarily selected as
991    /// generous upper limits.
992    BoundDeviceNames(Vec<String>),
993    #[doc(hidden)]
994    __SourceBreaking { unknown_ordinal: u64 },
995}
996
997/// Pattern that matches an unknown `Parameter` member.
998#[macro_export]
999macro_rules! ParameterUnknown {
1000    () => {
1001        _
1002    };
1003}
1004
1005// Custom PartialEq so that unknown variants are not equal to themselves.
1006impl PartialEq for Parameter {
1007    fn eq(&self, other: &Self) -> bool {
1008        match (self, other) {
1009            (Self::IpAddrs(x), Self::IpAddrs(y)) => *x == *y,
1010            (Self::AddressPool(x), Self::AddressPool(y)) => *x == *y,
1011            (Self::Lease(x), Self::Lease(y)) => *x == *y,
1012            (Self::PermittedMacs(x), Self::PermittedMacs(y)) => *x == *y,
1013            (Self::StaticallyAssignedAddrs(x), Self::StaticallyAssignedAddrs(y)) => *x == *y,
1014            (Self::ArpProbe(x), Self::ArpProbe(y)) => *x == *y,
1015            (Self::BoundDeviceNames(x), Self::BoundDeviceNames(y)) => *x == *y,
1016            _ => false,
1017        }
1018    }
1019}
1020
1021impl Parameter {
1022    #[inline]
1023    pub fn ordinal(&self) -> u64 {
1024        match *self {
1025            Self::IpAddrs(_) => 1,
1026            Self::AddressPool(_) => 2,
1027            Self::Lease(_) => 3,
1028            Self::PermittedMacs(_) => 4,
1029            Self::StaticallyAssignedAddrs(_) => 5,
1030            Self::ArpProbe(_) => 6,
1031            Self::BoundDeviceNames(_) => 7,
1032            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
1033        }
1034    }
1035
1036    #[inline]
1037    pub fn unknown_variant_for_testing() -> Self {
1038        Self::__SourceBreaking { unknown_ordinal: 0 }
1039    }
1040
1041    #[inline]
1042    pub fn is_unknown(&self) -> bool {
1043        match self {
1044            Self::__SourceBreaking { .. } => true,
1045            _ => false,
1046        }
1047    }
1048}
1049
1050impl fidl::Persistable for Parameter {}
1051
1052pub mod client_ordinals {
1053    pub const WATCH_CONFIGURATION: u64 = 0x2b6f7c7d3bcc6682;
1054    pub const SHUTDOWN: u64 = 0x265a3213e9a8abde;
1055    pub const ON_EXIT: u64 = 0x2a2a052260f657c0;
1056}
1057
1058pub mod client_provider_ordinals {
1059    pub const NEW_CLIENT: u64 = 0x317e9af2e462cbcd;
1060    pub const CHECK_PRESENCE: u64 = 0x7ba657cd730bbf60;
1061}
1062
1063pub mod server__ordinals {
1064    pub const START_SERVING: u64 = 0x10990e324ac53cd1;
1065    pub const STOP_SERVING: u64 = 0x7776cfe9f68a0dbe;
1066    pub const IS_SERVING: u64 = 0x45aadc35fcbe3826;
1067    pub const GET_OPTION: u64 = 0x5305ee2c593f68a;
1068    pub const GET_PARAMETER: u64 = 0x1e8c98758fb82714;
1069    pub const SET_OPTION: u64 = 0x63c98b670db8d96a;
1070    pub const SET_PARAMETER: u64 = 0x3002d0d956eb4bdc;
1071    pub const LIST_OPTIONS: u64 = 0x72c8161c69ca67b;
1072    pub const LIST_PARAMETERS: u64 = 0xa201b1d6d121c59;
1073    pub const RESET_OPTIONS: u64 = 0x31014911fd21cc13;
1074    pub const RESET_PARAMETERS: u64 = 0x353fba50bcf4ecec;
1075    pub const CLEAR_LEASES: u64 = 0xe39e35cda85a04d;
1076}
1077
1078mod internal {
1079    use super::*;
1080    unsafe impl fidl::encoding::TypeMarker for NodeTypes {
1081        type Owned = Self;
1082
1083        #[inline(always)]
1084        fn inline_align(_context: fidl::encoding::Context) -> usize {
1085            1
1086        }
1087
1088        #[inline(always)]
1089        fn inline_size(_context: fidl::encoding::Context) -> usize {
1090            1
1091        }
1092    }
1093
1094    impl fidl::encoding::ValueTypeMarker for NodeTypes {
1095        type Borrowed<'a> = Self;
1096        #[inline(always)]
1097        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1098            *value
1099        }
1100    }
1101
1102    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for NodeTypes {
1103        #[inline]
1104        unsafe fn encode(
1105            self,
1106            encoder: &mut fidl::encoding::Encoder<'_, D>,
1107            offset: usize,
1108            _depth: fidl::encoding::Depth,
1109        ) -> fidl::Result<()> {
1110            encoder.debug_check_bounds::<Self>(offset);
1111            if self.bits() & Self::all().bits() != self.bits() {
1112                return Err(fidl::Error::InvalidBitsValue);
1113            }
1114            encoder.write_num(self.bits(), offset);
1115            Ok(())
1116        }
1117    }
1118
1119    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeTypes {
1120        #[inline(always)]
1121        fn new_empty() -> Self {
1122            Self::empty()
1123        }
1124
1125        #[inline]
1126        unsafe fn decode(
1127            &mut self,
1128            decoder: &mut fidl::encoding::Decoder<'_, D>,
1129            offset: usize,
1130            _depth: fidl::encoding::Depth,
1131        ) -> fidl::Result<()> {
1132            decoder.debug_check_bounds::<Self>(offset);
1133            let prim = decoder.read_num::<u8>(offset);
1134            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
1135            Ok(())
1136        }
1137    }
1138    unsafe impl fidl::encoding::TypeMarker for ClientExitReason {
1139        type Owned = Self;
1140
1141        #[inline(always)]
1142        fn inline_align(_context: fidl::encoding::Context) -> usize {
1143            std::mem::align_of::<u32>()
1144        }
1145
1146        #[inline(always)]
1147        fn inline_size(_context: fidl::encoding::Context) -> usize {
1148            std::mem::size_of::<u32>()
1149        }
1150
1151        #[inline(always)]
1152        fn encode_is_copy() -> bool {
1153            true
1154        }
1155
1156        #[inline(always)]
1157        fn decode_is_copy() -> bool {
1158            false
1159        }
1160    }
1161
1162    impl fidl::encoding::ValueTypeMarker for ClientExitReason {
1163        type Borrowed<'a> = Self;
1164        #[inline(always)]
1165        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1166            *value
1167        }
1168    }
1169
1170    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1171        for ClientExitReason
1172    {
1173        #[inline]
1174        unsafe fn encode(
1175            self,
1176            encoder: &mut fidl::encoding::Encoder<'_, D>,
1177            offset: usize,
1178            _depth: fidl::encoding::Depth,
1179        ) -> fidl::Result<()> {
1180            encoder.debug_check_bounds::<Self>(offset);
1181            encoder.write_num(self.into_primitive(), offset);
1182            Ok(())
1183        }
1184    }
1185
1186    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ClientExitReason {
1187        #[inline(always)]
1188        fn new_empty() -> Self {
1189            Self::ClientAlreadyExistsOnInterface
1190        }
1191
1192        #[inline]
1193        unsafe fn decode(
1194            &mut self,
1195            decoder: &mut fidl::encoding::Decoder<'_, D>,
1196            offset: usize,
1197            _depth: fidl::encoding::Depth,
1198        ) -> fidl::Result<()> {
1199            decoder.debug_check_bounds::<Self>(offset);
1200            let prim = decoder.read_num::<u32>(offset);
1201
1202            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1203            Ok(())
1204        }
1205    }
1206    unsafe impl fidl::encoding::TypeMarker for MessageType {
1207        type Owned = Self;
1208
1209        #[inline(always)]
1210        fn inline_align(_context: fidl::encoding::Context) -> usize {
1211            std::mem::align_of::<u8>()
1212        }
1213
1214        #[inline(always)]
1215        fn inline_size(_context: fidl::encoding::Context) -> usize {
1216            std::mem::size_of::<u8>()
1217        }
1218
1219        #[inline(always)]
1220        fn encode_is_copy() -> bool {
1221            true
1222        }
1223
1224        #[inline(always)]
1225        fn decode_is_copy() -> bool {
1226            false
1227        }
1228    }
1229
1230    impl fidl::encoding::ValueTypeMarker for MessageType {
1231        type Borrowed<'a> = Self;
1232        #[inline(always)]
1233        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1234            *value
1235        }
1236    }
1237
1238    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for MessageType {
1239        #[inline]
1240        unsafe fn encode(
1241            self,
1242            encoder: &mut fidl::encoding::Encoder<'_, D>,
1243            offset: usize,
1244            _depth: fidl::encoding::Depth,
1245        ) -> fidl::Result<()> {
1246            encoder.debug_check_bounds::<Self>(offset);
1247            encoder.write_num(self.into_primitive(), offset);
1248            Ok(())
1249        }
1250    }
1251
1252    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MessageType {
1253        #[inline(always)]
1254        fn new_empty() -> Self {
1255            Self::Dhcpdiscover
1256        }
1257
1258        #[inline]
1259        unsafe fn decode(
1260            &mut self,
1261            decoder: &mut fidl::encoding::Decoder<'_, D>,
1262            offset: usize,
1263            _depth: fidl::encoding::Depth,
1264        ) -> fidl::Result<()> {
1265            decoder.debug_check_bounds::<Self>(offset);
1266            let prim = decoder.read_num::<u8>(offset);
1267
1268            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1269            Ok(())
1270        }
1271    }
1272    unsafe impl fidl::encoding::TypeMarker for OptionCode {
1273        type Owned = Self;
1274
1275        #[inline(always)]
1276        fn inline_align(_context: fidl::encoding::Context) -> usize {
1277            std::mem::align_of::<u32>()
1278        }
1279
1280        #[inline(always)]
1281        fn inline_size(_context: fidl::encoding::Context) -> usize {
1282            std::mem::size_of::<u32>()
1283        }
1284
1285        #[inline(always)]
1286        fn encode_is_copy() -> bool {
1287            true
1288        }
1289
1290        #[inline(always)]
1291        fn decode_is_copy() -> bool {
1292            false
1293        }
1294    }
1295
1296    impl fidl::encoding::ValueTypeMarker for OptionCode {
1297        type Borrowed<'a> = Self;
1298        #[inline(always)]
1299        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1300            *value
1301        }
1302    }
1303
1304    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for OptionCode {
1305        #[inline]
1306        unsafe fn encode(
1307            self,
1308            encoder: &mut fidl::encoding::Encoder<'_, D>,
1309            offset: usize,
1310            _depth: fidl::encoding::Depth,
1311        ) -> fidl::Result<()> {
1312            encoder.debug_check_bounds::<Self>(offset);
1313            encoder.write_num(self.into_primitive(), offset);
1314            Ok(())
1315        }
1316    }
1317
1318    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OptionCode {
1319        #[inline(always)]
1320        fn new_empty() -> Self {
1321            Self::SubnetMask
1322        }
1323
1324        #[inline]
1325        unsafe fn decode(
1326            &mut self,
1327            decoder: &mut fidl::encoding::Decoder<'_, D>,
1328            offset: usize,
1329            _depth: fidl::encoding::Depth,
1330        ) -> fidl::Result<()> {
1331            decoder.debug_check_bounds::<Self>(offset);
1332            let prim = decoder.read_num::<u32>(offset);
1333
1334            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1335            Ok(())
1336        }
1337    }
1338    unsafe impl fidl::encoding::TypeMarker for OptionOverloadValue {
1339        type Owned = Self;
1340
1341        #[inline(always)]
1342        fn inline_align(_context: fidl::encoding::Context) -> usize {
1343            std::mem::align_of::<u8>()
1344        }
1345
1346        #[inline(always)]
1347        fn inline_size(_context: fidl::encoding::Context) -> usize {
1348            std::mem::size_of::<u8>()
1349        }
1350
1351        #[inline(always)]
1352        fn encode_is_copy() -> bool {
1353            true
1354        }
1355
1356        #[inline(always)]
1357        fn decode_is_copy() -> bool {
1358            false
1359        }
1360    }
1361
1362    impl fidl::encoding::ValueTypeMarker for OptionOverloadValue {
1363        type Borrowed<'a> = Self;
1364        #[inline(always)]
1365        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1366            *value
1367        }
1368    }
1369
1370    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1371        for OptionOverloadValue
1372    {
1373        #[inline]
1374        unsafe fn encode(
1375            self,
1376            encoder: &mut fidl::encoding::Encoder<'_, D>,
1377            offset: usize,
1378            _depth: fidl::encoding::Depth,
1379        ) -> fidl::Result<()> {
1380            encoder.debug_check_bounds::<Self>(offset);
1381            encoder.write_num(self.into_primitive(), offset);
1382            Ok(())
1383        }
1384    }
1385
1386    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OptionOverloadValue {
1387        #[inline(always)]
1388        fn new_empty() -> Self {
1389            Self::File
1390        }
1391
1392        #[inline]
1393        unsafe fn decode(
1394            &mut self,
1395            decoder: &mut fidl::encoding::Decoder<'_, D>,
1396            offset: usize,
1397            _depth: fidl::encoding::Depth,
1398        ) -> fidl::Result<()> {
1399            decoder.debug_check_bounds::<Self>(offset);
1400            let prim = decoder.read_num::<u8>(offset);
1401
1402            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1403            Ok(())
1404        }
1405    }
1406    unsafe impl fidl::encoding::TypeMarker for ParameterName {
1407        type Owned = Self;
1408
1409        #[inline(always)]
1410        fn inline_align(_context: fidl::encoding::Context) -> usize {
1411            std::mem::align_of::<u32>()
1412        }
1413
1414        #[inline(always)]
1415        fn inline_size(_context: fidl::encoding::Context) -> usize {
1416            std::mem::size_of::<u32>()
1417        }
1418
1419        #[inline(always)]
1420        fn encode_is_copy() -> bool {
1421            true
1422        }
1423
1424        #[inline(always)]
1425        fn decode_is_copy() -> bool {
1426            false
1427        }
1428    }
1429
1430    impl fidl::encoding::ValueTypeMarker for ParameterName {
1431        type Borrowed<'a> = Self;
1432        #[inline(always)]
1433        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1434            *value
1435        }
1436    }
1437
1438    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ParameterName {
1439        #[inline]
1440        unsafe fn encode(
1441            self,
1442            encoder: &mut fidl::encoding::Encoder<'_, D>,
1443            offset: usize,
1444            _depth: fidl::encoding::Depth,
1445        ) -> fidl::Result<()> {
1446            encoder.debug_check_bounds::<Self>(offset);
1447            encoder.write_num(self.into_primitive(), offset);
1448            Ok(())
1449        }
1450    }
1451
1452    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ParameterName {
1453        #[inline(always)]
1454        fn new_empty() -> Self {
1455            Self::IpAddrs
1456        }
1457
1458        #[inline]
1459        unsafe fn decode(
1460            &mut self,
1461            decoder: &mut fidl::encoding::Decoder<'_, D>,
1462            offset: usize,
1463            _depth: fidl::encoding::Depth,
1464        ) -> fidl::Result<()> {
1465            decoder.debug_check_bounds::<Self>(offset);
1466            let prim = decoder.read_num::<u32>(offset);
1467
1468            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1469            Ok(())
1470        }
1471    }
1472
1473    impl fidl::encoding::ValueTypeMarker for ClientOnExitRequest {
1474        type Borrowed<'a> = &'a Self;
1475        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1476            value
1477        }
1478    }
1479
1480    unsafe impl fidl::encoding::TypeMarker for ClientOnExitRequest {
1481        type Owned = Self;
1482
1483        #[inline(always)]
1484        fn inline_align(_context: fidl::encoding::Context) -> usize {
1485            4
1486        }
1487
1488        #[inline(always)]
1489        fn inline_size(_context: fidl::encoding::Context) -> usize {
1490            4
1491        }
1492    }
1493
1494    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ClientOnExitRequest, D>
1495        for &ClientOnExitRequest
1496    {
1497        #[inline]
1498        unsafe fn encode(
1499            self,
1500            encoder: &mut fidl::encoding::Encoder<'_, D>,
1501            offset: usize,
1502            _depth: fidl::encoding::Depth,
1503        ) -> fidl::Result<()> {
1504            encoder.debug_check_bounds::<ClientOnExitRequest>(offset);
1505            // Delegate to tuple encoding.
1506            fidl::encoding::Encode::<ClientOnExitRequest, D>::encode(
1507                (<ClientExitReason as fidl::encoding::ValueTypeMarker>::borrow(&self.reason),),
1508                encoder,
1509                offset,
1510                _depth,
1511            )
1512        }
1513    }
1514    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ClientExitReason, D>>
1515        fidl::encoding::Encode<ClientOnExitRequest, D> for (T0,)
1516    {
1517        #[inline]
1518        unsafe fn encode(
1519            self,
1520            encoder: &mut fidl::encoding::Encoder<'_, D>,
1521            offset: usize,
1522            depth: fidl::encoding::Depth,
1523        ) -> fidl::Result<()> {
1524            encoder.debug_check_bounds::<ClientOnExitRequest>(offset);
1525            // Zero out padding regions. There's no need to apply masks
1526            // because the unmasked parts will be overwritten by fields.
1527            // Write the fields.
1528            self.0.encode(encoder, offset + 0, depth)?;
1529            Ok(())
1530        }
1531    }
1532
1533    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ClientOnExitRequest {
1534        #[inline(always)]
1535        fn new_empty() -> Self {
1536            Self { reason: fidl::new_empty!(ClientExitReason, D) }
1537        }
1538
1539        #[inline]
1540        unsafe fn decode(
1541            &mut self,
1542            decoder: &mut fidl::encoding::Decoder<'_, D>,
1543            offset: usize,
1544            _depth: fidl::encoding::Depth,
1545        ) -> fidl::Result<()> {
1546            decoder.debug_check_bounds::<Self>(offset);
1547            // Verify that padding bytes are zero.
1548            fidl::decode!(ClientExitReason, D, &mut self.reason, decoder, offset + 0, _depth)?;
1549            Ok(())
1550        }
1551    }
1552
1553    impl fidl::encoding::ValueTypeMarker for ServerGetOptionRequest {
1554        type Borrowed<'a> = &'a Self;
1555        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1556            value
1557        }
1558    }
1559
1560    unsafe impl fidl::encoding::TypeMarker for ServerGetOptionRequest {
1561        type Owned = Self;
1562
1563        #[inline(always)]
1564        fn inline_align(_context: fidl::encoding::Context) -> usize {
1565            4
1566        }
1567
1568        #[inline(always)]
1569        fn inline_size(_context: fidl::encoding::Context) -> usize {
1570            4
1571        }
1572    }
1573
1574    unsafe impl<D: fidl::encoding::ResourceDialect>
1575        fidl::encoding::Encode<ServerGetOptionRequest, D> for &ServerGetOptionRequest
1576    {
1577        #[inline]
1578        unsafe fn encode(
1579            self,
1580            encoder: &mut fidl::encoding::Encoder<'_, D>,
1581            offset: usize,
1582            _depth: fidl::encoding::Depth,
1583        ) -> fidl::Result<()> {
1584            encoder.debug_check_bounds::<ServerGetOptionRequest>(offset);
1585            // Delegate to tuple encoding.
1586            fidl::encoding::Encode::<ServerGetOptionRequest, D>::encode(
1587                (<OptionCode as fidl::encoding::ValueTypeMarker>::borrow(&self.code),),
1588                encoder,
1589                offset,
1590                _depth,
1591            )
1592        }
1593    }
1594    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<OptionCode, D>>
1595        fidl::encoding::Encode<ServerGetOptionRequest, D> for (T0,)
1596    {
1597        #[inline]
1598        unsafe fn encode(
1599            self,
1600            encoder: &mut fidl::encoding::Encoder<'_, D>,
1601            offset: usize,
1602            depth: fidl::encoding::Depth,
1603        ) -> fidl::Result<()> {
1604            encoder.debug_check_bounds::<ServerGetOptionRequest>(offset);
1605            // Zero out padding regions. There's no need to apply masks
1606            // because the unmasked parts will be overwritten by fields.
1607            // Write the fields.
1608            self.0.encode(encoder, offset + 0, depth)?;
1609            Ok(())
1610        }
1611    }
1612
1613    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1614        for ServerGetOptionRequest
1615    {
1616        #[inline(always)]
1617        fn new_empty() -> Self {
1618            Self { code: fidl::new_empty!(OptionCode, D) }
1619        }
1620
1621        #[inline]
1622        unsafe fn decode(
1623            &mut self,
1624            decoder: &mut fidl::encoding::Decoder<'_, D>,
1625            offset: usize,
1626            _depth: fidl::encoding::Depth,
1627        ) -> fidl::Result<()> {
1628            decoder.debug_check_bounds::<Self>(offset);
1629            // Verify that padding bytes are zero.
1630            fidl::decode!(OptionCode, D, &mut self.code, decoder, offset + 0, _depth)?;
1631            Ok(())
1632        }
1633    }
1634
1635    impl fidl::encoding::ValueTypeMarker for ServerGetParameterRequest {
1636        type Borrowed<'a> = &'a Self;
1637        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1638            value
1639        }
1640    }
1641
1642    unsafe impl fidl::encoding::TypeMarker for ServerGetParameterRequest {
1643        type Owned = Self;
1644
1645        #[inline(always)]
1646        fn inline_align(_context: fidl::encoding::Context) -> usize {
1647            4
1648        }
1649
1650        #[inline(always)]
1651        fn inline_size(_context: fidl::encoding::Context) -> usize {
1652            4
1653        }
1654    }
1655
1656    unsafe impl<D: fidl::encoding::ResourceDialect>
1657        fidl::encoding::Encode<ServerGetParameterRequest, D> for &ServerGetParameterRequest
1658    {
1659        #[inline]
1660        unsafe fn encode(
1661            self,
1662            encoder: &mut fidl::encoding::Encoder<'_, D>,
1663            offset: usize,
1664            _depth: fidl::encoding::Depth,
1665        ) -> fidl::Result<()> {
1666            encoder.debug_check_bounds::<ServerGetParameterRequest>(offset);
1667            // Delegate to tuple encoding.
1668            fidl::encoding::Encode::<ServerGetParameterRequest, D>::encode(
1669                (<ParameterName as fidl::encoding::ValueTypeMarker>::borrow(&self.name),),
1670                encoder,
1671                offset,
1672                _depth,
1673            )
1674        }
1675    }
1676    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ParameterName, D>>
1677        fidl::encoding::Encode<ServerGetParameterRequest, D> for (T0,)
1678    {
1679        #[inline]
1680        unsafe fn encode(
1681            self,
1682            encoder: &mut fidl::encoding::Encoder<'_, D>,
1683            offset: usize,
1684            depth: fidl::encoding::Depth,
1685        ) -> fidl::Result<()> {
1686            encoder.debug_check_bounds::<ServerGetParameterRequest>(offset);
1687            // Zero out padding regions. There's no need to apply masks
1688            // because the unmasked parts will be overwritten by fields.
1689            // Write the fields.
1690            self.0.encode(encoder, offset + 0, depth)?;
1691            Ok(())
1692        }
1693    }
1694
1695    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1696        for ServerGetParameterRequest
1697    {
1698        #[inline(always)]
1699        fn new_empty() -> Self {
1700            Self { name: fidl::new_empty!(ParameterName, D) }
1701        }
1702
1703        #[inline]
1704        unsafe fn decode(
1705            &mut self,
1706            decoder: &mut fidl::encoding::Decoder<'_, D>,
1707            offset: usize,
1708            _depth: fidl::encoding::Depth,
1709        ) -> fidl::Result<()> {
1710            decoder.debug_check_bounds::<Self>(offset);
1711            // Verify that padding bytes are zero.
1712            fidl::decode!(ParameterName, D, &mut self.name, decoder, offset + 0, _depth)?;
1713            Ok(())
1714        }
1715    }
1716
1717    impl fidl::encoding::ValueTypeMarker for ServerIsServingResponse {
1718        type Borrowed<'a> = &'a Self;
1719        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1720            value
1721        }
1722    }
1723
1724    unsafe impl fidl::encoding::TypeMarker for ServerIsServingResponse {
1725        type Owned = Self;
1726
1727        #[inline(always)]
1728        fn inline_align(_context: fidl::encoding::Context) -> usize {
1729            1
1730        }
1731
1732        #[inline(always)]
1733        fn inline_size(_context: fidl::encoding::Context) -> usize {
1734            1
1735        }
1736    }
1737
1738    unsafe impl<D: fidl::encoding::ResourceDialect>
1739        fidl::encoding::Encode<ServerIsServingResponse, D> for &ServerIsServingResponse
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::<ServerIsServingResponse>(offset);
1749            // Delegate to tuple encoding.
1750            fidl::encoding::Encode::<ServerIsServingResponse, D>::encode(
1751                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.enabled),),
1752                encoder,
1753                offset,
1754                _depth,
1755            )
1756        }
1757    }
1758    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
1759        fidl::encoding::Encode<ServerIsServingResponse, D> for (T0,)
1760    {
1761        #[inline]
1762        unsafe fn encode(
1763            self,
1764            encoder: &mut fidl::encoding::Encoder<'_, D>,
1765            offset: usize,
1766            depth: fidl::encoding::Depth,
1767        ) -> fidl::Result<()> {
1768            encoder.debug_check_bounds::<ServerIsServingResponse>(offset);
1769            // Zero out padding regions. There's no need to apply masks
1770            // because the unmasked parts will be overwritten by fields.
1771            // Write the fields.
1772            self.0.encode(encoder, offset + 0, depth)?;
1773            Ok(())
1774        }
1775    }
1776
1777    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1778        for ServerIsServingResponse
1779    {
1780        #[inline(always)]
1781        fn new_empty() -> Self {
1782            Self { enabled: fidl::new_empty!(bool, D) }
1783        }
1784
1785        #[inline]
1786        unsafe fn decode(
1787            &mut self,
1788            decoder: &mut fidl::encoding::Decoder<'_, D>,
1789            offset: usize,
1790            _depth: fidl::encoding::Depth,
1791        ) -> fidl::Result<()> {
1792            decoder.debug_check_bounds::<Self>(offset);
1793            // Verify that padding bytes are zero.
1794            fidl::decode!(bool, D, &mut self.enabled, decoder, offset + 0, _depth)?;
1795            Ok(())
1796        }
1797    }
1798
1799    impl fidl::encoding::ValueTypeMarker for ServerSetOptionRequest {
1800        type Borrowed<'a> = &'a Self;
1801        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1802            value
1803        }
1804    }
1805
1806    unsafe impl fidl::encoding::TypeMarker for ServerSetOptionRequest {
1807        type Owned = Self;
1808
1809        #[inline(always)]
1810        fn inline_align(_context: fidl::encoding::Context) -> usize {
1811            8
1812        }
1813
1814        #[inline(always)]
1815        fn inline_size(_context: fidl::encoding::Context) -> usize {
1816            16
1817        }
1818    }
1819
1820    unsafe impl<D: fidl::encoding::ResourceDialect>
1821        fidl::encoding::Encode<ServerSetOptionRequest, D> for &ServerSetOptionRequest
1822    {
1823        #[inline]
1824        unsafe fn encode(
1825            self,
1826            encoder: &mut fidl::encoding::Encoder<'_, D>,
1827            offset: usize,
1828            _depth: fidl::encoding::Depth,
1829        ) -> fidl::Result<()> {
1830            encoder.debug_check_bounds::<ServerSetOptionRequest>(offset);
1831            // Delegate to tuple encoding.
1832            fidl::encoding::Encode::<ServerSetOptionRequest, D>::encode(
1833                (<Option_ as fidl::encoding::ValueTypeMarker>::borrow(&self.value),),
1834                encoder,
1835                offset,
1836                _depth,
1837            )
1838        }
1839    }
1840    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Option_, D>>
1841        fidl::encoding::Encode<ServerSetOptionRequest, D> for (T0,)
1842    {
1843        #[inline]
1844        unsafe fn encode(
1845            self,
1846            encoder: &mut fidl::encoding::Encoder<'_, D>,
1847            offset: usize,
1848            depth: fidl::encoding::Depth,
1849        ) -> fidl::Result<()> {
1850            encoder.debug_check_bounds::<ServerSetOptionRequest>(offset);
1851            // Zero out padding regions. There's no need to apply masks
1852            // because the unmasked parts will be overwritten by fields.
1853            // Write the fields.
1854            self.0.encode(encoder, offset + 0, depth)?;
1855            Ok(())
1856        }
1857    }
1858
1859    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1860        for ServerSetOptionRequest
1861    {
1862        #[inline(always)]
1863        fn new_empty() -> Self {
1864            Self { value: fidl::new_empty!(Option_, D) }
1865        }
1866
1867        #[inline]
1868        unsafe fn decode(
1869            &mut self,
1870            decoder: &mut fidl::encoding::Decoder<'_, D>,
1871            offset: usize,
1872            _depth: fidl::encoding::Depth,
1873        ) -> fidl::Result<()> {
1874            decoder.debug_check_bounds::<Self>(offset);
1875            // Verify that padding bytes are zero.
1876            fidl::decode!(Option_, D, &mut self.value, decoder, offset + 0, _depth)?;
1877            Ok(())
1878        }
1879    }
1880
1881    impl fidl::encoding::ValueTypeMarker for ServerSetParameterRequest {
1882        type Borrowed<'a> = &'a Self;
1883        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1884            value
1885        }
1886    }
1887
1888    unsafe impl fidl::encoding::TypeMarker for ServerSetParameterRequest {
1889        type Owned = Self;
1890
1891        #[inline(always)]
1892        fn inline_align(_context: fidl::encoding::Context) -> usize {
1893            8
1894        }
1895
1896        #[inline(always)]
1897        fn inline_size(_context: fidl::encoding::Context) -> usize {
1898            16
1899        }
1900    }
1901
1902    unsafe impl<D: fidl::encoding::ResourceDialect>
1903        fidl::encoding::Encode<ServerSetParameterRequest, D> for &ServerSetParameterRequest
1904    {
1905        #[inline]
1906        unsafe fn encode(
1907            self,
1908            encoder: &mut fidl::encoding::Encoder<'_, D>,
1909            offset: usize,
1910            _depth: fidl::encoding::Depth,
1911        ) -> fidl::Result<()> {
1912            encoder.debug_check_bounds::<ServerSetParameterRequest>(offset);
1913            // Delegate to tuple encoding.
1914            fidl::encoding::Encode::<ServerSetParameterRequest, D>::encode(
1915                (<Parameter as fidl::encoding::ValueTypeMarker>::borrow(&self.value),),
1916                encoder,
1917                offset,
1918                _depth,
1919            )
1920        }
1921    }
1922    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Parameter, D>>
1923        fidl::encoding::Encode<ServerSetParameterRequest, D> for (T0,)
1924    {
1925        #[inline]
1926        unsafe fn encode(
1927            self,
1928            encoder: &mut fidl::encoding::Encoder<'_, D>,
1929            offset: usize,
1930            depth: fidl::encoding::Depth,
1931        ) -> fidl::Result<()> {
1932            encoder.debug_check_bounds::<ServerSetParameterRequest>(offset);
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 ServerSetParameterRequest
1943    {
1944        #[inline(always)]
1945        fn new_empty() -> Self {
1946            Self { value: fidl::new_empty!(Parameter, D) }
1947        }
1948
1949        #[inline]
1950        unsafe fn decode(
1951            &mut self,
1952            decoder: &mut fidl::encoding::Decoder<'_, D>,
1953            offset: usize,
1954            _depth: fidl::encoding::Depth,
1955        ) -> fidl::Result<()> {
1956            decoder.debug_check_bounds::<Self>(offset);
1957            // Verify that padding bytes are zero.
1958            fidl::decode!(Parameter, D, &mut self.value, decoder, offset + 0, _depth)?;
1959            Ok(())
1960        }
1961    }
1962
1963    impl fidl::encoding::ValueTypeMarker for ServerGetOptionResponse {
1964        type Borrowed<'a> = &'a Self;
1965        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1966            value
1967        }
1968    }
1969
1970    unsafe impl fidl::encoding::TypeMarker for ServerGetOptionResponse {
1971        type Owned = Self;
1972
1973        #[inline(always)]
1974        fn inline_align(_context: fidl::encoding::Context) -> usize {
1975            8
1976        }
1977
1978        #[inline(always)]
1979        fn inline_size(_context: fidl::encoding::Context) -> usize {
1980            16
1981        }
1982    }
1983
1984    unsafe impl<D: fidl::encoding::ResourceDialect>
1985        fidl::encoding::Encode<ServerGetOptionResponse, D> for &ServerGetOptionResponse
1986    {
1987        #[inline]
1988        unsafe fn encode(
1989            self,
1990            encoder: &mut fidl::encoding::Encoder<'_, D>,
1991            offset: usize,
1992            _depth: fidl::encoding::Depth,
1993        ) -> fidl::Result<()> {
1994            encoder.debug_check_bounds::<ServerGetOptionResponse>(offset);
1995            // Delegate to tuple encoding.
1996            fidl::encoding::Encode::<ServerGetOptionResponse, D>::encode(
1997                (<Option_ as fidl::encoding::ValueTypeMarker>::borrow(&self.value),),
1998                encoder,
1999                offset,
2000                _depth,
2001            )
2002        }
2003    }
2004    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Option_, D>>
2005        fidl::encoding::Encode<ServerGetOptionResponse, D> for (T0,)
2006    {
2007        #[inline]
2008        unsafe fn encode(
2009            self,
2010            encoder: &mut fidl::encoding::Encoder<'_, D>,
2011            offset: usize,
2012            depth: fidl::encoding::Depth,
2013        ) -> fidl::Result<()> {
2014            encoder.debug_check_bounds::<ServerGetOptionResponse>(offset);
2015            // Zero out padding regions. There's no need to apply masks
2016            // because the unmasked parts will be overwritten by fields.
2017            // Write the fields.
2018            self.0.encode(encoder, offset + 0, depth)?;
2019            Ok(())
2020        }
2021    }
2022
2023    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2024        for ServerGetOptionResponse
2025    {
2026        #[inline(always)]
2027        fn new_empty() -> Self {
2028            Self { value: fidl::new_empty!(Option_, D) }
2029        }
2030
2031        #[inline]
2032        unsafe fn decode(
2033            &mut self,
2034            decoder: &mut fidl::encoding::Decoder<'_, D>,
2035            offset: usize,
2036            _depth: fidl::encoding::Depth,
2037        ) -> fidl::Result<()> {
2038            decoder.debug_check_bounds::<Self>(offset);
2039            // Verify that padding bytes are zero.
2040            fidl::decode!(Option_, D, &mut self.value, decoder, offset + 0, _depth)?;
2041            Ok(())
2042        }
2043    }
2044
2045    impl fidl::encoding::ValueTypeMarker for ServerGetParameterResponse {
2046        type Borrowed<'a> = &'a Self;
2047        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2048            value
2049        }
2050    }
2051
2052    unsafe impl fidl::encoding::TypeMarker for ServerGetParameterResponse {
2053        type Owned = Self;
2054
2055        #[inline(always)]
2056        fn inline_align(_context: fidl::encoding::Context) -> usize {
2057            8
2058        }
2059
2060        #[inline(always)]
2061        fn inline_size(_context: fidl::encoding::Context) -> usize {
2062            16
2063        }
2064    }
2065
2066    unsafe impl<D: fidl::encoding::ResourceDialect>
2067        fidl::encoding::Encode<ServerGetParameterResponse, D> for &ServerGetParameterResponse
2068    {
2069        #[inline]
2070        unsafe fn encode(
2071            self,
2072            encoder: &mut fidl::encoding::Encoder<'_, D>,
2073            offset: usize,
2074            _depth: fidl::encoding::Depth,
2075        ) -> fidl::Result<()> {
2076            encoder.debug_check_bounds::<ServerGetParameterResponse>(offset);
2077            // Delegate to tuple encoding.
2078            fidl::encoding::Encode::<ServerGetParameterResponse, D>::encode(
2079                (<Parameter as fidl::encoding::ValueTypeMarker>::borrow(&self.value),),
2080                encoder,
2081                offset,
2082                _depth,
2083            )
2084        }
2085    }
2086    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Parameter, D>>
2087        fidl::encoding::Encode<ServerGetParameterResponse, D> for (T0,)
2088    {
2089        #[inline]
2090        unsafe fn encode(
2091            self,
2092            encoder: &mut fidl::encoding::Encoder<'_, D>,
2093            offset: usize,
2094            depth: fidl::encoding::Depth,
2095        ) -> fidl::Result<()> {
2096            encoder.debug_check_bounds::<ServerGetParameterResponse>(offset);
2097            // Zero out padding regions. There's no need to apply masks
2098            // because the unmasked parts will be overwritten by fields.
2099            // Write the fields.
2100            self.0.encode(encoder, offset + 0, depth)?;
2101            Ok(())
2102        }
2103    }
2104
2105    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2106        for ServerGetParameterResponse
2107    {
2108        #[inline(always)]
2109        fn new_empty() -> Self {
2110            Self { value: fidl::new_empty!(Parameter, D) }
2111        }
2112
2113        #[inline]
2114        unsafe fn decode(
2115            &mut self,
2116            decoder: &mut fidl::encoding::Decoder<'_, D>,
2117            offset: usize,
2118            _depth: fidl::encoding::Depth,
2119        ) -> fidl::Result<()> {
2120            decoder.debug_check_bounds::<Self>(offset);
2121            // Verify that padding bytes are zero.
2122            fidl::decode!(Parameter, D, &mut self.value, decoder, offset + 0, _depth)?;
2123            Ok(())
2124        }
2125    }
2126
2127    impl fidl::encoding::ValueTypeMarker for ServerListOptionsResponse {
2128        type Borrowed<'a> = &'a Self;
2129        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2130            value
2131        }
2132    }
2133
2134    unsafe impl fidl::encoding::TypeMarker for ServerListOptionsResponse {
2135        type Owned = Self;
2136
2137        #[inline(always)]
2138        fn inline_align(_context: fidl::encoding::Context) -> usize {
2139            8
2140        }
2141
2142        #[inline(always)]
2143        fn inline_size(_context: fidl::encoding::Context) -> usize {
2144            16
2145        }
2146    }
2147
2148    unsafe impl<D: fidl::encoding::ResourceDialect>
2149        fidl::encoding::Encode<ServerListOptionsResponse, D> for &ServerListOptionsResponse
2150    {
2151        #[inline]
2152        unsafe fn encode(
2153            self,
2154            encoder: &mut fidl::encoding::Encoder<'_, D>,
2155            offset: usize,
2156            _depth: fidl::encoding::Depth,
2157        ) -> fidl::Result<()> {
2158            encoder.debug_check_bounds::<ServerListOptionsResponse>(offset);
2159            // Delegate to tuple encoding.
2160            fidl::encoding::Encode::<ServerListOptionsResponse, D>::encode(
2161                (
2162                    <fidl::encoding::Vector<Option_, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
2163                ),
2164                encoder, offset, _depth
2165            )
2166        }
2167    }
2168    unsafe impl<
2169            D: fidl::encoding::ResourceDialect,
2170            T0: fidl::encoding::Encode<fidl::encoding::Vector<Option_, 256>, D>,
2171        > fidl::encoding::Encode<ServerListOptionsResponse, D> for (T0,)
2172    {
2173        #[inline]
2174        unsafe fn encode(
2175            self,
2176            encoder: &mut fidl::encoding::Encoder<'_, D>,
2177            offset: usize,
2178            depth: fidl::encoding::Depth,
2179        ) -> fidl::Result<()> {
2180            encoder.debug_check_bounds::<ServerListOptionsResponse>(offset);
2181            // Zero out padding regions. There's no need to apply masks
2182            // because the unmasked parts will be overwritten by fields.
2183            // Write the fields.
2184            self.0.encode(encoder, offset + 0, depth)?;
2185            Ok(())
2186        }
2187    }
2188
2189    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2190        for ServerListOptionsResponse
2191    {
2192        #[inline(always)]
2193        fn new_empty() -> Self {
2194            Self { options: fidl::new_empty!(fidl::encoding::Vector<Option_, 256>, D) }
2195        }
2196
2197        #[inline]
2198        unsafe fn decode(
2199            &mut self,
2200            decoder: &mut fidl::encoding::Decoder<'_, D>,
2201            offset: usize,
2202            _depth: fidl::encoding::Depth,
2203        ) -> fidl::Result<()> {
2204            decoder.debug_check_bounds::<Self>(offset);
2205            // Verify that padding bytes are zero.
2206            fidl::decode!(fidl::encoding::Vector<Option_, 256>, D, &mut self.options, decoder, offset + 0, _depth)?;
2207            Ok(())
2208        }
2209    }
2210
2211    impl fidl::encoding::ValueTypeMarker for ServerListParametersResponse {
2212        type Borrowed<'a> = &'a Self;
2213        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2214            value
2215        }
2216    }
2217
2218    unsafe impl fidl::encoding::TypeMarker for ServerListParametersResponse {
2219        type Owned = Self;
2220
2221        #[inline(always)]
2222        fn inline_align(_context: fidl::encoding::Context) -> usize {
2223            8
2224        }
2225
2226        #[inline(always)]
2227        fn inline_size(_context: fidl::encoding::Context) -> usize {
2228            16
2229        }
2230    }
2231
2232    unsafe impl<D: fidl::encoding::ResourceDialect>
2233        fidl::encoding::Encode<ServerListParametersResponse, D> for &ServerListParametersResponse
2234    {
2235        #[inline]
2236        unsafe fn encode(
2237            self,
2238            encoder: &mut fidl::encoding::Encoder<'_, D>,
2239            offset: usize,
2240            _depth: fidl::encoding::Depth,
2241        ) -> fidl::Result<()> {
2242            encoder.debug_check_bounds::<ServerListParametersResponse>(offset);
2243            // Delegate to tuple encoding.
2244            fidl::encoding::Encode::<ServerListParametersResponse, D>::encode(
2245                (
2246                    <fidl::encoding::Vector<Parameter, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.parameters),
2247                ),
2248                encoder, offset, _depth
2249            )
2250        }
2251    }
2252    unsafe impl<
2253            D: fidl::encoding::ResourceDialect,
2254            T0: fidl::encoding::Encode<fidl::encoding::Vector<Parameter, 256>, D>,
2255        > fidl::encoding::Encode<ServerListParametersResponse, D> for (T0,)
2256    {
2257        #[inline]
2258        unsafe fn encode(
2259            self,
2260            encoder: &mut fidl::encoding::Encoder<'_, D>,
2261            offset: usize,
2262            depth: fidl::encoding::Depth,
2263        ) -> fidl::Result<()> {
2264            encoder.debug_check_bounds::<ServerListParametersResponse>(offset);
2265            // Zero out padding regions. There's no need to apply masks
2266            // because the unmasked parts will be overwritten by fields.
2267            // Write the fields.
2268            self.0.encode(encoder, offset + 0, depth)?;
2269            Ok(())
2270        }
2271    }
2272
2273    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2274        for ServerListParametersResponse
2275    {
2276        #[inline(always)]
2277        fn new_empty() -> Self {
2278            Self { parameters: fidl::new_empty!(fidl::encoding::Vector<Parameter, 256>, D) }
2279        }
2280
2281        #[inline]
2282        unsafe fn decode(
2283            &mut self,
2284            decoder: &mut fidl::encoding::Decoder<'_, D>,
2285            offset: usize,
2286            _depth: fidl::encoding::Depth,
2287        ) -> fidl::Result<()> {
2288            decoder.debug_check_bounds::<Self>(offset);
2289            // Verify that padding bytes are zero.
2290            fidl::decode!(fidl::encoding::Vector<Parameter, 256>, D, &mut self.parameters, decoder, offset + 0, _depth)?;
2291            Ok(())
2292        }
2293    }
2294
2295    impl AddressPool {
2296        #[inline(always)]
2297        fn max_ordinal_present(&self) -> u64 {
2298            if let Some(_) = self.range_stop {
2299                return 3;
2300            }
2301            if let Some(_) = self.range_start {
2302                return 2;
2303            }
2304            if let Some(_) = self.prefix_length {
2305                return 1;
2306            }
2307            0
2308        }
2309    }
2310
2311    impl fidl::encoding::ValueTypeMarker for AddressPool {
2312        type Borrowed<'a> = &'a Self;
2313        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2314            value
2315        }
2316    }
2317
2318    unsafe impl fidl::encoding::TypeMarker for AddressPool {
2319        type Owned = Self;
2320
2321        #[inline(always)]
2322        fn inline_align(_context: fidl::encoding::Context) -> usize {
2323            8
2324        }
2325
2326        #[inline(always)]
2327        fn inline_size(_context: fidl::encoding::Context) -> usize {
2328            16
2329        }
2330    }
2331
2332    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AddressPool, D>
2333        for &AddressPool
2334    {
2335        unsafe fn encode(
2336            self,
2337            encoder: &mut fidl::encoding::Encoder<'_, D>,
2338            offset: usize,
2339            mut depth: fidl::encoding::Depth,
2340        ) -> fidl::Result<()> {
2341            encoder.debug_check_bounds::<AddressPool>(offset);
2342            // Vector header
2343            let max_ordinal: u64 = self.max_ordinal_present();
2344            encoder.write_num(max_ordinal, offset);
2345            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2346            // Calling encoder.out_of_line_offset(0) is not allowed.
2347            if max_ordinal == 0 {
2348                return Ok(());
2349            }
2350            depth.increment()?;
2351            let envelope_size = 8;
2352            let bytes_len = max_ordinal as usize * envelope_size;
2353            #[allow(unused_variables)]
2354            let offset = encoder.out_of_line_offset(bytes_len);
2355            let mut _prev_end_offset: usize = 0;
2356            if 1 > max_ordinal {
2357                return Ok(());
2358            }
2359
2360            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2361            // are envelope_size bytes.
2362            let cur_offset: usize = (1 - 1) * envelope_size;
2363
2364            // Zero reserved fields.
2365            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2366
2367            // Safety:
2368            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2369            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2370            //   envelope_size bytes, there is always sufficient room.
2371            fidl::encoding::encode_in_envelope_optional::<u8, D>(
2372                self.prefix_length.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
2373                encoder,
2374                offset + cur_offset,
2375                depth,
2376            )?;
2377
2378            _prev_end_offset = cur_offset + envelope_size;
2379            if 2 > max_ordinal {
2380                return Ok(());
2381            }
2382
2383            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2384            // are envelope_size bytes.
2385            let cur_offset: usize = (2 - 1) * envelope_size;
2386
2387            // Zero reserved fields.
2388            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2389
2390            // Safety:
2391            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2392            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2393            //   envelope_size bytes, there is always sufficient room.
2394            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv4Address, D>(
2395            self.range_start.as_ref().map(<fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow),
2396            encoder, offset + cur_offset, depth
2397        )?;
2398
2399            _prev_end_offset = cur_offset + envelope_size;
2400            if 3 > max_ordinal {
2401                return Ok(());
2402            }
2403
2404            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2405            // are envelope_size bytes.
2406            let cur_offset: usize = (3 - 1) * envelope_size;
2407
2408            // Zero reserved fields.
2409            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2410
2411            // Safety:
2412            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2413            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2414            //   envelope_size bytes, there is always sufficient room.
2415            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv4Address, D>(
2416            self.range_stop.as_ref().map(<fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow),
2417            encoder, offset + cur_offset, depth
2418        )?;
2419
2420            _prev_end_offset = cur_offset + envelope_size;
2421
2422            Ok(())
2423        }
2424    }
2425
2426    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AddressPool {
2427        #[inline(always)]
2428        fn new_empty() -> Self {
2429            Self::default()
2430        }
2431
2432        unsafe fn decode(
2433            &mut self,
2434            decoder: &mut fidl::encoding::Decoder<'_, D>,
2435            offset: usize,
2436            mut depth: fidl::encoding::Depth,
2437        ) -> fidl::Result<()> {
2438            decoder.debug_check_bounds::<Self>(offset);
2439            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2440                None => return Err(fidl::Error::NotNullable),
2441                Some(len) => len,
2442            };
2443            // Calling decoder.out_of_line_offset(0) is not allowed.
2444            if len == 0 {
2445                return Ok(());
2446            };
2447            depth.increment()?;
2448            let envelope_size = 8;
2449            let bytes_len = len * envelope_size;
2450            let offset = decoder.out_of_line_offset(bytes_len)?;
2451            // Decode the envelope for each type.
2452            let mut _next_ordinal_to_read = 0;
2453            let mut next_offset = offset;
2454            let end_offset = offset + bytes_len;
2455            _next_ordinal_to_read += 1;
2456            if next_offset >= end_offset {
2457                return Ok(());
2458            }
2459
2460            // Decode unknown envelopes for gaps in ordinals.
2461            while _next_ordinal_to_read < 1 {
2462                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2463                _next_ordinal_to_read += 1;
2464                next_offset += envelope_size;
2465            }
2466
2467            let next_out_of_line = decoder.next_out_of_line();
2468            let handles_before = decoder.remaining_handles();
2469            if let Some((inlined, num_bytes, num_handles)) =
2470                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2471            {
2472                let member_inline_size =
2473                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2474                if inlined != (member_inline_size <= 4) {
2475                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2476                }
2477                let inner_offset;
2478                let mut inner_depth = depth.clone();
2479                if inlined {
2480                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2481                    inner_offset = next_offset;
2482                } else {
2483                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2484                    inner_depth.increment()?;
2485                }
2486                let val_ref = self.prefix_length.get_or_insert_with(|| fidl::new_empty!(u8, D));
2487                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
2488                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2489                {
2490                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2491                }
2492                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2493                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2494                }
2495            }
2496
2497            next_offset += envelope_size;
2498            _next_ordinal_to_read += 1;
2499            if next_offset >= end_offset {
2500                return Ok(());
2501            }
2502
2503            // Decode unknown envelopes for gaps in ordinals.
2504            while _next_ordinal_to_read < 2 {
2505                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2506                _next_ordinal_to_read += 1;
2507                next_offset += envelope_size;
2508            }
2509
2510            let next_out_of_line = decoder.next_out_of_line();
2511            let handles_before = decoder.remaining_handles();
2512            if let Some((inlined, num_bytes, num_handles)) =
2513                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2514            {
2515                let member_inline_size = <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2516                if inlined != (member_inline_size <= 4) {
2517                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2518                }
2519                let inner_offset;
2520                let mut inner_depth = depth.clone();
2521                if inlined {
2522                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2523                    inner_offset = next_offset;
2524                } else {
2525                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2526                    inner_depth.increment()?;
2527                }
2528                let val_ref = self.range_start.get_or_insert_with(|| {
2529                    fidl::new_empty!(fidl_fuchsia_net__common::Ipv4Address, D)
2530                });
2531                fidl::decode!(
2532                    fidl_fuchsia_net__common::Ipv4Address,
2533                    D,
2534                    val_ref,
2535                    decoder,
2536                    inner_offset,
2537                    inner_depth
2538                )?;
2539                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2540                {
2541                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2542                }
2543                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2544                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2545                }
2546            }
2547
2548            next_offset += envelope_size;
2549            _next_ordinal_to_read += 1;
2550            if next_offset >= end_offset {
2551                return Ok(());
2552            }
2553
2554            // Decode unknown envelopes for gaps in ordinals.
2555            while _next_ordinal_to_read < 3 {
2556                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2557                _next_ordinal_to_read += 1;
2558                next_offset += envelope_size;
2559            }
2560
2561            let next_out_of_line = decoder.next_out_of_line();
2562            let handles_before = decoder.remaining_handles();
2563            if let Some((inlined, num_bytes, num_handles)) =
2564                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2565            {
2566                let member_inline_size = <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2567                if inlined != (member_inline_size <= 4) {
2568                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2569                }
2570                let inner_offset;
2571                let mut inner_depth = depth.clone();
2572                if inlined {
2573                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2574                    inner_offset = next_offset;
2575                } else {
2576                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2577                    inner_depth.increment()?;
2578                }
2579                let val_ref = self.range_stop.get_or_insert_with(|| {
2580                    fidl::new_empty!(fidl_fuchsia_net__common::Ipv4Address, D)
2581                });
2582                fidl::decode!(
2583                    fidl_fuchsia_net__common::Ipv4Address,
2584                    D,
2585                    val_ref,
2586                    decoder,
2587                    inner_offset,
2588                    inner_depth
2589                )?;
2590                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2591                {
2592                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2593                }
2594                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2595                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2596                }
2597            }
2598
2599            next_offset += envelope_size;
2600
2601            // Decode the remaining unknown envelopes.
2602            while next_offset < end_offset {
2603                _next_ordinal_to_read += 1;
2604                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2605                next_offset += envelope_size;
2606            }
2607
2608            Ok(())
2609        }
2610    }
2611
2612    impl ConfigurationToRequest {
2613        #[inline(always)]
2614        fn max_ordinal_present(&self) -> u64 {
2615            if let Some(_) = self.dns_servers {
2616                return 2;
2617            }
2618            if let Some(_) = self.routers {
2619                return 1;
2620            }
2621            0
2622        }
2623    }
2624
2625    impl fidl::encoding::ValueTypeMarker for ConfigurationToRequest {
2626        type Borrowed<'a> = &'a Self;
2627        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2628            value
2629        }
2630    }
2631
2632    unsafe impl fidl::encoding::TypeMarker for ConfigurationToRequest {
2633        type Owned = Self;
2634
2635        #[inline(always)]
2636        fn inline_align(_context: fidl::encoding::Context) -> usize {
2637            8
2638        }
2639
2640        #[inline(always)]
2641        fn inline_size(_context: fidl::encoding::Context) -> usize {
2642            16
2643        }
2644    }
2645
2646    unsafe impl<D: fidl::encoding::ResourceDialect>
2647        fidl::encoding::Encode<ConfigurationToRequest, D> for &ConfigurationToRequest
2648    {
2649        unsafe fn encode(
2650            self,
2651            encoder: &mut fidl::encoding::Encoder<'_, D>,
2652            offset: usize,
2653            mut depth: fidl::encoding::Depth,
2654        ) -> fidl::Result<()> {
2655            encoder.debug_check_bounds::<ConfigurationToRequest>(offset);
2656            // Vector header
2657            let max_ordinal: u64 = self.max_ordinal_present();
2658            encoder.write_num(max_ordinal, offset);
2659            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2660            // Calling encoder.out_of_line_offset(0) is not allowed.
2661            if max_ordinal == 0 {
2662                return Ok(());
2663            }
2664            depth.increment()?;
2665            let envelope_size = 8;
2666            let bytes_len = max_ordinal as usize * envelope_size;
2667            #[allow(unused_variables)]
2668            let offset = encoder.out_of_line_offset(bytes_len);
2669            let mut _prev_end_offset: usize = 0;
2670            if 1 > max_ordinal {
2671                return Ok(());
2672            }
2673
2674            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2675            // are envelope_size bytes.
2676            let cur_offset: usize = (1 - 1) * envelope_size;
2677
2678            // Zero reserved fields.
2679            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2680
2681            // Safety:
2682            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2683            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2684            //   envelope_size bytes, there is always sufficient room.
2685            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2686                self.routers.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2687                encoder,
2688                offset + cur_offset,
2689                depth,
2690            )?;
2691
2692            _prev_end_offset = cur_offset + envelope_size;
2693            if 2 > max_ordinal {
2694                return Ok(());
2695            }
2696
2697            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2698            // are envelope_size bytes.
2699            let cur_offset: usize = (2 - 1) * envelope_size;
2700
2701            // Zero reserved fields.
2702            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2703
2704            // Safety:
2705            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2706            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2707            //   envelope_size bytes, there is always sufficient room.
2708            fidl::encoding::encode_in_envelope_optional::<bool, D>(
2709                self.dns_servers.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
2710                encoder,
2711                offset + cur_offset,
2712                depth,
2713            )?;
2714
2715            _prev_end_offset = cur_offset + envelope_size;
2716
2717            Ok(())
2718        }
2719    }
2720
2721    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2722        for ConfigurationToRequest
2723    {
2724        #[inline(always)]
2725        fn new_empty() -> Self {
2726            Self::default()
2727        }
2728
2729        unsafe fn decode(
2730            &mut self,
2731            decoder: &mut fidl::encoding::Decoder<'_, D>,
2732            offset: usize,
2733            mut depth: fidl::encoding::Depth,
2734        ) -> fidl::Result<()> {
2735            decoder.debug_check_bounds::<Self>(offset);
2736            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2737                None => return Err(fidl::Error::NotNullable),
2738                Some(len) => len,
2739            };
2740            // Calling decoder.out_of_line_offset(0) is not allowed.
2741            if len == 0 {
2742                return Ok(());
2743            };
2744            depth.increment()?;
2745            let envelope_size = 8;
2746            let bytes_len = len * envelope_size;
2747            let offset = decoder.out_of_line_offset(bytes_len)?;
2748            // Decode the envelope for each type.
2749            let mut _next_ordinal_to_read = 0;
2750            let mut next_offset = offset;
2751            let end_offset = offset + bytes_len;
2752            _next_ordinal_to_read += 1;
2753            if next_offset >= end_offset {
2754                return Ok(());
2755            }
2756
2757            // Decode unknown envelopes for gaps in ordinals.
2758            while _next_ordinal_to_read < 1 {
2759                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2760                _next_ordinal_to_read += 1;
2761                next_offset += envelope_size;
2762            }
2763
2764            let next_out_of_line = decoder.next_out_of_line();
2765            let handles_before = decoder.remaining_handles();
2766            if let Some((inlined, num_bytes, num_handles)) =
2767                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2768            {
2769                let member_inline_size =
2770                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2771                if inlined != (member_inline_size <= 4) {
2772                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2773                }
2774                let inner_offset;
2775                let mut inner_depth = depth.clone();
2776                if inlined {
2777                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2778                    inner_offset = next_offset;
2779                } else {
2780                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2781                    inner_depth.increment()?;
2782                }
2783                let val_ref = self.routers.get_or_insert_with(|| fidl::new_empty!(bool, D));
2784                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2785                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2786                {
2787                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2788                }
2789                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2790                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2791                }
2792            }
2793
2794            next_offset += envelope_size;
2795            _next_ordinal_to_read += 1;
2796            if next_offset >= end_offset {
2797                return Ok(());
2798            }
2799
2800            // Decode unknown envelopes for gaps in ordinals.
2801            while _next_ordinal_to_read < 2 {
2802                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2803                _next_ordinal_to_read += 1;
2804                next_offset += envelope_size;
2805            }
2806
2807            let next_out_of_line = decoder.next_out_of_line();
2808            let handles_before = decoder.remaining_handles();
2809            if let Some((inlined, num_bytes, num_handles)) =
2810                fidl::encoding::decode_envelope_header(decoder, next_offset)?
2811            {
2812                let member_inline_size =
2813                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
2814                if inlined != (member_inline_size <= 4) {
2815                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
2816                }
2817                let inner_offset;
2818                let mut inner_depth = depth.clone();
2819                if inlined {
2820                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
2821                    inner_offset = next_offset;
2822                } else {
2823                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
2824                    inner_depth.increment()?;
2825                }
2826                let val_ref = self.dns_servers.get_or_insert_with(|| fidl::new_empty!(bool, D));
2827                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
2828                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
2829                {
2830                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
2831                }
2832                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
2833                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
2834                }
2835            }
2836
2837            next_offset += envelope_size;
2838
2839            // Decode the remaining unknown envelopes.
2840            while next_offset < end_offset {
2841                _next_ordinal_to_read += 1;
2842                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2843                next_offset += envelope_size;
2844            }
2845
2846            Ok(())
2847        }
2848    }
2849
2850    impl LeaseLength {
2851        #[inline(always)]
2852        fn max_ordinal_present(&self) -> u64 {
2853            if let Some(_) = self.max {
2854                return 2;
2855            }
2856            if let Some(_) = self.default {
2857                return 1;
2858            }
2859            0
2860        }
2861    }
2862
2863    impl fidl::encoding::ValueTypeMarker for LeaseLength {
2864        type Borrowed<'a> = &'a Self;
2865        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2866            value
2867        }
2868    }
2869
2870    unsafe impl fidl::encoding::TypeMarker for LeaseLength {
2871        type Owned = Self;
2872
2873        #[inline(always)]
2874        fn inline_align(_context: fidl::encoding::Context) -> usize {
2875            8
2876        }
2877
2878        #[inline(always)]
2879        fn inline_size(_context: fidl::encoding::Context) -> usize {
2880            16
2881        }
2882    }
2883
2884    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LeaseLength, D>
2885        for &LeaseLength
2886    {
2887        unsafe fn encode(
2888            self,
2889            encoder: &mut fidl::encoding::Encoder<'_, D>,
2890            offset: usize,
2891            mut depth: fidl::encoding::Depth,
2892        ) -> fidl::Result<()> {
2893            encoder.debug_check_bounds::<LeaseLength>(offset);
2894            // Vector header
2895            let max_ordinal: u64 = self.max_ordinal_present();
2896            encoder.write_num(max_ordinal, offset);
2897            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
2898            // Calling encoder.out_of_line_offset(0) is not allowed.
2899            if max_ordinal == 0 {
2900                return Ok(());
2901            }
2902            depth.increment()?;
2903            let envelope_size = 8;
2904            let bytes_len = max_ordinal as usize * envelope_size;
2905            #[allow(unused_variables)]
2906            let offset = encoder.out_of_line_offset(bytes_len);
2907            let mut _prev_end_offset: usize = 0;
2908            if 1 > max_ordinal {
2909                return Ok(());
2910            }
2911
2912            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2913            // are envelope_size bytes.
2914            let cur_offset: usize = (1 - 1) * envelope_size;
2915
2916            // Zero reserved fields.
2917            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2918
2919            // Safety:
2920            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2921            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2922            //   envelope_size bytes, there is always sufficient room.
2923            fidl::encoding::encode_in_envelope_optional::<u32, D>(
2924                self.default.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2925                encoder,
2926                offset + cur_offset,
2927                depth,
2928            )?;
2929
2930            _prev_end_offset = cur_offset + envelope_size;
2931            if 2 > max_ordinal {
2932                return Ok(());
2933            }
2934
2935            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
2936            // are envelope_size bytes.
2937            let cur_offset: usize = (2 - 1) * envelope_size;
2938
2939            // Zero reserved fields.
2940            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
2941
2942            // Safety:
2943            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
2944            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
2945            //   envelope_size bytes, there is always sufficient room.
2946            fidl::encoding::encode_in_envelope_optional::<u32, D>(
2947                self.max.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
2948                encoder,
2949                offset + cur_offset,
2950                depth,
2951            )?;
2952
2953            _prev_end_offset = cur_offset + envelope_size;
2954
2955            Ok(())
2956        }
2957    }
2958
2959    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LeaseLength {
2960        #[inline(always)]
2961        fn new_empty() -> Self {
2962            Self::default()
2963        }
2964
2965        unsafe fn decode(
2966            &mut self,
2967            decoder: &mut fidl::encoding::Decoder<'_, D>,
2968            offset: usize,
2969            mut depth: fidl::encoding::Depth,
2970        ) -> fidl::Result<()> {
2971            decoder.debug_check_bounds::<Self>(offset);
2972            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
2973                None => return Err(fidl::Error::NotNullable),
2974                Some(len) => len,
2975            };
2976            // Calling decoder.out_of_line_offset(0) is not allowed.
2977            if len == 0 {
2978                return Ok(());
2979            };
2980            depth.increment()?;
2981            let envelope_size = 8;
2982            let bytes_len = len * envelope_size;
2983            let offset = decoder.out_of_line_offset(bytes_len)?;
2984            // Decode the envelope for each type.
2985            let mut _next_ordinal_to_read = 0;
2986            let mut next_offset = offset;
2987            let end_offset = offset + bytes_len;
2988            _next_ordinal_to_read += 1;
2989            if next_offset >= end_offset {
2990                return Ok(());
2991            }
2992
2993            // Decode unknown envelopes for gaps in ordinals.
2994            while _next_ordinal_to_read < 1 {
2995                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
2996                _next_ordinal_to_read += 1;
2997                next_offset += envelope_size;
2998            }
2999
3000            let next_out_of_line = decoder.next_out_of_line();
3001            let handles_before = decoder.remaining_handles();
3002            if let Some((inlined, num_bytes, num_handles)) =
3003                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3004            {
3005                let member_inline_size =
3006                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3007                if inlined != (member_inline_size <= 4) {
3008                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3009                }
3010                let inner_offset;
3011                let mut inner_depth = depth.clone();
3012                if inlined {
3013                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3014                    inner_offset = next_offset;
3015                } else {
3016                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3017                    inner_depth.increment()?;
3018                }
3019                let val_ref = self.default.get_or_insert_with(|| fidl::new_empty!(u32, D));
3020                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3021                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3022                {
3023                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3024                }
3025                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3026                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3027                }
3028            }
3029
3030            next_offset += envelope_size;
3031            _next_ordinal_to_read += 1;
3032            if next_offset >= end_offset {
3033                return Ok(());
3034            }
3035
3036            // Decode unknown envelopes for gaps in ordinals.
3037            while _next_ordinal_to_read < 2 {
3038                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3039                _next_ordinal_to_read += 1;
3040                next_offset += envelope_size;
3041            }
3042
3043            let next_out_of_line = decoder.next_out_of_line();
3044            let handles_before = decoder.remaining_handles();
3045            if let Some((inlined, num_bytes, num_handles)) =
3046                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3047            {
3048                let member_inline_size =
3049                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3050                if inlined != (member_inline_size <= 4) {
3051                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3052                }
3053                let inner_offset;
3054                let mut inner_depth = depth.clone();
3055                if inlined {
3056                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3057                    inner_offset = next_offset;
3058                } else {
3059                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3060                    inner_depth.increment()?;
3061                }
3062                let val_ref = self.max.get_or_insert_with(|| fidl::new_empty!(u32, D));
3063                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
3064                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3065                {
3066                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3067                }
3068                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3069                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3070                }
3071            }
3072
3073            next_offset += envelope_size;
3074
3075            // Decode the remaining unknown envelopes.
3076            while next_offset < end_offset {
3077                _next_ordinal_to_read += 1;
3078                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3079                next_offset += envelope_size;
3080            }
3081
3082            Ok(())
3083        }
3084    }
3085
3086    impl NewClientParams {
3087        #[inline(always)]
3088        fn max_ordinal_present(&self) -> u64 {
3089            if let Some(_) = self.request_ip_address {
3090                return 2;
3091            }
3092            if let Some(_) = self.configuration_to_request {
3093                return 1;
3094            }
3095            0
3096        }
3097    }
3098
3099    impl fidl::encoding::ValueTypeMarker for NewClientParams {
3100        type Borrowed<'a> = &'a Self;
3101        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3102            value
3103        }
3104    }
3105
3106    unsafe impl fidl::encoding::TypeMarker for NewClientParams {
3107        type Owned = Self;
3108
3109        #[inline(always)]
3110        fn inline_align(_context: fidl::encoding::Context) -> usize {
3111            8
3112        }
3113
3114        #[inline(always)]
3115        fn inline_size(_context: fidl::encoding::Context) -> usize {
3116            16
3117        }
3118    }
3119
3120    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NewClientParams, D>
3121        for &NewClientParams
3122    {
3123        unsafe fn encode(
3124            self,
3125            encoder: &mut fidl::encoding::Encoder<'_, D>,
3126            offset: usize,
3127            mut depth: fidl::encoding::Depth,
3128        ) -> fidl::Result<()> {
3129            encoder.debug_check_bounds::<NewClientParams>(offset);
3130            // Vector header
3131            let max_ordinal: u64 = self.max_ordinal_present();
3132            encoder.write_num(max_ordinal, offset);
3133            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3134            // Calling encoder.out_of_line_offset(0) is not allowed.
3135            if max_ordinal == 0 {
3136                return Ok(());
3137            }
3138            depth.increment()?;
3139            let envelope_size = 8;
3140            let bytes_len = max_ordinal as usize * envelope_size;
3141            #[allow(unused_variables)]
3142            let offset = encoder.out_of_line_offset(bytes_len);
3143            let mut _prev_end_offset: usize = 0;
3144            if 1 > max_ordinal {
3145                return Ok(());
3146            }
3147
3148            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3149            // are envelope_size bytes.
3150            let cur_offset: usize = (1 - 1) * envelope_size;
3151
3152            // Zero reserved fields.
3153            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3154
3155            // Safety:
3156            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3157            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3158            //   envelope_size bytes, there is always sufficient room.
3159            fidl::encoding::encode_in_envelope_optional::<ConfigurationToRequest, D>(
3160                self.configuration_to_request
3161                    .as_ref()
3162                    .map(<ConfigurationToRequest as fidl::encoding::ValueTypeMarker>::borrow),
3163                encoder,
3164                offset + cur_offset,
3165                depth,
3166            )?;
3167
3168            _prev_end_offset = cur_offset + envelope_size;
3169            if 2 > max_ordinal {
3170                return Ok(());
3171            }
3172
3173            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3174            // are envelope_size bytes.
3175            let cur_offset: usize = (2 - 1) * envelope_size;
3176
3177            // Zero reserved fields.
3178            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3179
3180            // Safety:
3181            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3182            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3183            //   envelope_size bytes, there is always sufficient room.
3184            fidl::encoding::encode_in_envelope_optional::<bool, D>(
3185                self.request_ip_address
3186                    .as_ref()
3187                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
3188                encoder,
3189                offset + cur_offset,
3190                depth,
3191            )?;
3192
3193            _prev_end_offset = cur_offset + envelope_size;
3194
3195            Ok(())
3196        }
3197    }
3198
3199    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NewClientParams {
3200        #[inline(always)]
3201        fn new_empty() -> Self {
3202            Self::default()
3203        }
3204
3205        unsafe fn decode(
3206            &mut self,
3207            decoder: &mut fidl::encoding::Decoder<'_, D>,
3208            offset: usize,
3209            mut depth: fidl::encoding::Depth,
3210        ) -> fidl::Result<()> {
3211            decoder.debug_check_bounds::<Self>(offset);
3212            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3213                None => return Err(fidl::Error::NotNullable),
3214                Some(len) => len,
3215            };
3216            // Calling decoder.out_of_line_offset(0) is not allowed.
3217            if len == 0 {
3218                return Ok(());
3219            };
3220            depth.increment()?;
3221            let envelope_size = 8;
3222            let bytes_len = len * envelope_size;
3223            let offset = decoder.out_of_line_offset(bytes_len)?;
3224            // Decode the envelope for each type.
3225            let mut _next_ordinal_to_read = 0;
3226            let mut next_offset = offset;
3227            let end_offset = offset + bytes_len;
3228            _next_ordinal_to_read += 1;
3229            if next_offset >= end_offset {
3230                return Ok(());
3231            }
3232
3233            // Decode unknown envelopes for gaps in ordinals.
3234            while _next_ordinal_to_read < 1 {
3235                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3236                _next_ordinal_to_read += 1;
3237                next_offset += envelope_size;
3238            }
3239
3240            let next_out_of_line = decoder.next_out_of_line();
3241            let handles_before = decoder.remaining_handles();
3242            if let Some((inlined, num_bytes, num_handles)) =
3243                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3244            {
3245                let member_inline_size =
3246                    <ConfigurationToRequest as fidl::encoding::TypeMarker>::inline_size(
3247                        decoder.context,
3248                    );
3249                if inlined != (member_inline_size <= 4) {
3250                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3251                }
3252                let inner_offset;
3253                let mut inner_depth = depth.clone();
3254                if inlined {
3255                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3256                    inner_offset = next_offset;
3257                } else {
3258                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3259                    inner_depth.increment()?;
3260                }
3261                let val_ref = self
3262                    .configuration_to_request
3263                    .get_or_insert_with(|| fidl::new_empty!(ConfigurationToRequest, D));
3264                fidl::decode!(
3265                    ConfigurationToRequest,
3266                    D,
3267                    val_ref,
3268                    decoder,
3269                    inner_offset,
3270                    inner_depth
3271                )?;
3272                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3273                {
3274                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3275                }
3276                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3277                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3278                }
3279            }
3280
3281            next_offset += envelope_size;
3282            _next_ordinal_to_read += 1;
3283            if next_offset >= end_offset {
3284                return Ok(());
3285            }
3286
3287            // Decode unknown envelopes for gaps in ordinals.
3288            while _next_ordinal_to_read < 2 {
3289                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3290                _next_ordinal_to_read += 1;
3291                next_offset += envelope_size;
3292            }
3293
3294            let next_out_of_line = decoder.next_out_of_line();
3295            let handles_before = decoder.remaining_handles();
3296            if let Some((inlined, num_bytes, num_handles)) =
3297                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3298            {
3299                let member_inline_size =
3300                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3301                if inlined != (member_inline_size <= 4) {
3302                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3303                }
3304                let inner_offset;
3305                let mut inner_depth = depth.clone();
3306                if inlined {
3307                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3308                    inner_offset = next_offset;
3309                } else {
3310                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3311                    inner_depth.increment()?;
3312                }
3313                let val_ref =
3314                    self.request_ip_address.get_or_insert_with(|| fidl::new_empty!(bool, D));
3315                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
3316                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3317                {
3318                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3319                }
3320                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3321                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3322                }
3323            }
3324
3325            next_offset += envelope_size;
3326
3327            // Decode the remaining unknown envelopes.
3328            while next_offset < end_offset {
3329                _next_ordinal_to_read += 1;
3330                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3331                next_offset += envelope_size;
3332            }
3333
3334            Ok(())
3335        }
3336    }
3337
3338    impl StaticAssignment {
3339        #[inline(always)]
3340        fn max_ordinal_present(&self) -> u64 {
3341            if let Some(_) = self.assigned_addr {
3342                return 2;
3343            }
3344            if let Some(_) = self.host {
3345                return 1;
3346            }
3347            0
3348        }
3349    }
3350
3351    impl fidl::encoding::ValueTypeMarker for StaticAssignment {
3352        type Borrowed<'a> = &'a Self;
3353        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3354            value
3355        }
3356    }
3357
3358    unsafe impl fidl::encoding::TypeMarker for StaticAssignment {
3359        type Owned = Self;
3360
3361        #[inline(always)]
3362        fn inline_align(_context: fidl::encoding::Context) -> usize {
3363            8
3364        }
3365
3366        #[inline(always)]
3367        fn inline_size(_context: fidl::encoding::Context) -> usize {
3368            16
3369        }
3370    }
3371
3372    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StaticAssignment, D>
3373        for &StaticAssignment
3374    {
3375        unsafe fn encode(
3376            self,
3377            encoder: &mut fidl::encoding::Encoder<'_, D>,
3378            offset: usize,
3379            mut depth: fidl::encoding::Depth,
3380        ) -> fidl::Result<()> {
3381            encoder.debug_check_bounds::<StaticAssignment>(offset);
3382            // Vector header
3383            let max_ordinal: u64 = self.max_ordinal_present();
3384            encoder.write_num(max_ordinal, offset);
3385            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3386            // Calling encoder.out_of_line_offset(0) is not allowed.
3387            if max_ordinal == 0 {
3388                return Ok(());
3389            }
3390            depth.increment()?;
3391            let envelope_size = 8;
3392            let bytes_len = max_ordinal as usize * envelope_size;
3393            #[allow(unused_variables)]
3394            let offset = encoder.out_of_line_offset(bytes_len);
3395            let mut _prev_end_offset: usize = 0;
3396            if 1 > max_ordinal {
3397                return Ok(());
3398            }
3399
3400            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3401            // are envelope_size bytes.
3402            let cur_offset: usize = (1 - 1) * envelope_size;
3403
3404            // Zero reserved fields.
3405            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3406
3407            // Safety:
3408            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3409            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3410            //   envelope_size bytes, there is always sufficient room.
3411            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::MacAddress, D>(
3412            self.host.as_ref().map(<fidl_fuchsia_net__common::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
3413            encoder, offset + cur_offset, depth
3414        )?;
3415
3416            _prev_end_offset = cur_offset + envelope_size;
3417            if 2 > max_ordinal {
3418                return Ok(());
3419            }
3420
3421            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3422            // are envelope_size bytes.
3423            let cur_offset: usize = (2 - 1) * envelope_size;
3424
3425            // Zero reserved fields.
3426            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3427
3428            // Safety:
3429            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3430            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3431            //   envelope_size bytes, there is always sufficient room.
3432            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net__common::Ipv4Address, D>(
3433            self.assigned_addr.as_ref().map(<fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow),
3434            encoder, offset + cur_offset, depth
3435        )?;
3436
3437            _prev_end_offset = cur_offset + envelope_size;
3438
3439            Ok(())
3440        }
3441    }
3442
3443    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StaticAssignment {
3444        #[inline(always)]
3445        fn new_empty() -> Self {
3446            Self::default()
3447        }
3448
3449        unsafe fn decode(
3450            &mut self,
3451            decoder: &mut fidl::encoding::Decoder<'_, D>,
3452            offset: usize,
3453            mut depth: fidl::encoding::Depth,
3454        ) -> fidl::Result<()> {
3455            decoder.debug_check_bounds::<Self>(offset);
3456            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3457                None => return Err(fidl::Error::NotNullable),
3458                Some(len) => len,
3459            };
3460            // Calling decoder.out_of_line_offset(0) is not allowed.
3461            if len == 0 {
3462                return Ok(());
3463            };
3464            depth.increment()?;
3465            let envelope_size = 8;
3466            let bytes_len = len * envelope_size;
3467            let offset = decoder.out_of_line_offset(bytes_len)?;
3468            // Decode the envelope for each type.
3469            let mut _next_ordinal_to_read = 0;
3470            let mut next_offset = offset;
3471            let end_offset = offset + bytes_len;
3472            _next_ordinal_to_read += 1;
3473            if next_offset >= end_offset {
3474                return Ok(());
3475            }
3476
3477            // Decode unknown envelopes for gaps in ordinals.
3478            while _next_ordinal_to_read < 1 {
3479                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3480                _next_ordinal_to_read += 1;
3481                next_offset += envelope_size;
3482            }
3483
3484            let next_out_of_line = decoder.next_out_of_line();
3485            let handles_before = decoder.remaining_handles();
3486            if let Some((inlined, num_bytes, num_handles)) =
3487                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3488            {
3489                let member_inline_size = <fidl_fuchsia_net__common::MacAddress as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3490                if inlined != (member_inline_size <= 4) {
3491                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3492                }
3493                let inner_offset;
3494                let mut inner_depth = depth.clone();
3495                if inlined {
3496                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3497                    inner_offset = next_offset;
3498                } else {
3499                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3500                    inner_depth.increment()?;
3501                }
3502                let val_ref = self.host.get_or_insert_with(|| {
3503                    fidl::new_empty!(fidl_fuchsia_net__common::MacAddress, D)
3504                });
3505                fidl::decode!(
3506                    fidl_fuchsia_net__common::MacAddress,
3507                    D,
3508                    val_ref,
3509                    decoder,
3510                    inner_offset,
3511                    inner_depth
3512                )?;
3513                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3514                {
3515                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3516                }
3517                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3518                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3519                }
3520            }
3521
3522            next_offset += envelope_size;
3523            _next_ordinal_to_read += 1;
3524            if next_offset >= end_offset {
3525                return Ok(());
3526            }
3527
3528            // Decode unknown envelopes for gaps in ordinals.
3529            while _next_ordinal_to_read < 2 {
3530                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3531                _next_ordinal_to_read += 1;
3532                next_offset += envelope_size;
3533            }
3534
3535            let next_out_of_line = decoder.next_out_of_line();
3536            let handles_before = decoder.remaining_handles();
3537            if let Some((inlined, num_bytes, num_handles)) =
3538                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3539            {
3540                let member_inline_size = <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3541                if inlined != (member_inline_size <= 4) {
3542                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3543                }
3544                let inner_offset;
3545                let mut inner_depth = depth.clone();
3546                if inlined {
3547                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3548                    inner_offset = next_offset;
3549                } else {
3550                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3551                    inner_depth.increment()?;
3552                }
3553                let val_ref = self.assigned_addr.get_or_insert_with(|| {
3554                    fidl::new_empty!(fidl_fuchsia_net__common::Ipv4Address, D)
3555                });
3556                fidl::decode!(
3557                    fidl_fuchsia_net__common::Ipv4Address,
3558                    D,
3559                    val_ref,
3560                    decoder,
3561                    inner_offset,
3562                    inner_depth
3563                )?;
3564                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3565                {
3566                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3567                }
3568                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3569                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3570                }
3571            }
3572
3573            next_offset += envelope_size;
3574
3575            // Decode the remaining unknown envelopes.
3576            while next_offset < end_offset {
3577                _next_ordinal_to_read += 1;
3578                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3579                next_offset += envelope_size;
3580            }
3581
3582            Ok(())
3583        }
3584    }
3585
3586    impl fidl::encoding::ValueTypeMarker for Option_ {
3587        type Borrowed<'a> = &'a Self;
3588        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3589            value
3590        }
3591    }
3592
3593    unsafe impl fidl::encoding::TypeMarker for Option_ {
3594        type Owned = Self;
3595
3596        #[inline(always)]
3597        fn inline_align(_context: fidl::encoding::Context) -> usize {
3598            8
3599        }
3600
3601        #[inline(always)]
3602        fn inline_size(_context: fidl::encoding::Context) -> usize {
3603            16
3604        }
3605    }
3606
3607    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Option_, D> for &Option_ {
3608        #[inline]
3609        unsafe fn encode(
3610            self,
3611            encoder: &mut fidl::encoding::Encoder<'_, D>,
3612            offset: usize,
3613            _depth: fidl::encoding::Depth,
3614        ) -> fidl::Result<()> {
3615            encoder.debug_check_bounds::<Option_>(offset);
3616            encoder.write_num::<u64>(self.ordinal(), offset);
3617            match self {
3618            Option_::SubnetMask(ref val) => {
3619                fidl::encoding::encode_in_envelope::<fidl_fuchsia_net__common::Ipv4Address, D>(
3620                    <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow(val),
3621                    encoder, offset + 8, _depth
3622                )
3623            }
3624            Option_::TimeOffset(ref val) => {
3625                fidl::encoding::encode_in_envelope::<i32, D>(
3626                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
3627                    encoder, offset + 8, _depth
3628                )
3629            }
3630            Option_::Router(ref val) => {
3631                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3632                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3633                    encoder, offset + 8, _depth
3634                )
3635            }
3636            Option_::TimeServer(ref val) => {
3637                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3638                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3639                    encoder, offset + 8, _depth
3640                )
3641            }
3642            Option_::NameServer(ref val) => {
3643                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3644                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3645                    encoder, offset + 8, _depth
3646                )
3647            }
3648            Option_::DomainNameServer(ref val) => {
3649                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3650                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3651                    encoder, offset + 8, _depth
3652                )
3653            }
3654            Option_::LogServer(ref val) => {
3655                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3656                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3657                    encoder, offset + 8, _depth
3658                )
3659            }
3660            Option_::CookieServer(ref val) => {
3661                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3662                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3663                    encoder, offset + 8, _depth
3664                )
3665            }
3666            Option_::LprServer(ref val) => {
3667                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3668                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3669                    encoder, offset + 8, _depth
3670                )
3671            }
3672            Option_::ImpressServer(ref val) => {
3673                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3674                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3675                    encoder, offset + 8, _depth
3676                )
3677            }
3678            Option_::ResourceLocationServer(ref val) => {
3679                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3680                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3681                    encoder, offset + 8, _depth
3682                )
3683            }
3684            Option_::HostName(ref val) => {
3685                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3686                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3687                    encoder, offset + 8, _depth
3688                )
3689            }
3690            Option_::BootFileSize(ref val) => {
3691                fidl::encoding::encode_in_envelope::<u16, D>(
3692                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
3693                    encoder, offset + 8, _depth
3694                )
3695            }
3696            Option_::MeritDumpFile(ref val) => {
3697                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3698                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3699                    encoder, offset + 8, _depth
3700                )
3701            }
3702            Option_::DomainName(ref val) => {
3703                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3704                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3705                    encoder, offset + 8, _depth
3706                )
3707            }
3708            Option_::SwapServer(ref val) => {
3709                fidl::encoding::encode_in_envelope::<fidl_fuchsia_net__common::Ipv4Address, D>(
3710                    <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow(val),
3711                    encoder, offset + 8, _depth
3712                )
3713            }
3714            Option_::RootPath(ref val) => {
3715                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3716                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3717                    encoder, offset + 8, _depth
3718                )
3719            }
3720            Option_::ExtensionsPath(ref val) => {
3721                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3722                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3723                    encoder, offset + 8, _depth
3724                )
3725            }
3726            Option_::IpForwarding(ref val) => {
3727                fidl::encoding::encode_in_envelope::<bool, D>(
3728                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3729                    encoder, offset + 8, _depth
3730                )
3731            }
3732            Option_::NonLocalSourceRouting(ref val) => {
3733                fidl::encoding::encode_in_envelope::<bool, D>(
3734                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3735                    encoder, offset + 8, _depth
3736                )
3737            }
3738            Option_::PolicyFilter(ref val) => {
3739                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3740                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3741                    encoder, offset + 8, _depth
3742                )
3743            }
3744            Option_::MaxDatagramReassemblySize(ref val) => {
3745                fidl::encoding::encode_in_envelope::<u16, D>(
3746                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
3747                    encoder, offset + 8, _depth
3748                )
3749            }
3750            Option_::DefaultIpTtl(ref val) => {
3751                fidl::encoding::encode_in_envelope::<u8, D>(
3752                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
3753                    encoder, offset + 8, _depth
3754                )
3755            }
3756            Option_::PathMtuAgingTimeout(ref val) => {
3757                fidl::encoding::encode_in_envelope::<u32, D>(
3758                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
3759                    encoder, offset + 8, _depth
3760                )
3761            }
3762            Option_::PathMtuPlateauTable(ref val) => {
3763                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<u16, 127>, D>(
3764                    <fidl::encoding::Vector<u16, 127> as fidl::encoding::ValueTypeMarker>::borrow(val),
3765                    encoder, offset + 8, _depth
3766                )
3767            }
3768            Option_::InterfaceMtu(ref val) => {
3769                fidl::encoding::encode_in_envelope::<u16, D>(
3770                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
3771                    encoder, offset + 8, _depth
3772                )
3773            }
3774            Option_::AllSubnetsLocal(ref val) => {
3775                fidl::encoding::encode_in_envelope::<bool, D>(
3776                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3777                    encoder, offset + 8, _depth
3778                )
3779            }
3780            Option_::BroadcastAddress(ref val) => {
3781                fidl::encoding::encode_in_envelope::<fidl_fuchsia_net__common::Ipv4Address, D>(
3782                    <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow(val),
3783                    encoder, offset + 8, _depth
3784                )
3785            }
3786            Option_::PerformMaskDiscovery(ref val) => {
3787                fidl::encoding::encode_in_envelope::<bool, D>(
3788                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3789                    encoder, offset + 8, _depth
3790                )
3791            }
3792            Option_::MaskSupplier(ref val) => {
3793                fidl::encoding::encode_in_envelope::<bool, D>(
3794                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3795                    encoder, offset + 8, _depth
3796                )
3797            }
3798            Option_::PerformRouterDiscovery(ref val) => {
3799                fidl::encoding::encode_in_envelope::<bool, D>(
3800                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3801                    encoder, offset + 8, _depth
3802                )
3803            }
3804            Option_::RouterSolicitationAddress(ref val) => {
3805                fidl::encoding::encode_in_envelope::<fidl_fuchsia_net__common::Ipv4Address, D>(
3806                    <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow(val),
3807                    encoder, offset + 8, _depth
3808                )
3809            }
3810            Option_::StaticRoute(ref val) => {
3811                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3812                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3813                    encoder, offset + 8, _depth
3814                )
3815            }
3816            Option_::TrailerEncapsulation(ref val) => {
3817                fidl::encoding::encode_in_envelope::<bool, D>(
3818                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3819                    encoder, offset + 8, _depth
3820                )
3821            }
3822            Option_::ArpCacheTimeout(ref val) => {
3823                fidl::encoding::encode_in_envelope::<u32, D>(
3824                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
3825                    encoder, offset + 8, _depth
3826                )
3827            }
3828            Option_::EthernetEncapsulation(ref val) => {
3829                fidl::encoding::encode_in_envelope::<bool, D>(
3830                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3831                    encoder, offset + 8, _depth
3832                )
3833            }
3834            Option_::TcpDefaultTtl(ref val) => {
3835                fidl::encoding::encode_in_envelope::<u8, D>(
3836                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
3837                    encoder, offset + 8, _depth
3838                )
3839            }
3840            Option_::TcpKeepaliveInterval(ref val) => {
3841                fidl::encoding::encode_in_envelope::<u32, D>(
3842                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
3843                    encoder, offset + 8, _depth
3844                )
3845            }
3846            Option_::TcpKeepaliveGarbage(ref val) => {
3847                fidl::encoding::encode_in_envelope::<bool, D>(
3848                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
3849                    encoder, offset + 8, _depth
3850                )
3851            }
3852            Option_::NetworkInformationServiceDomain(ref val) => {
3853                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3854                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3855                    encoder, offset + 8, _depth
3856                )
3857            }
3858            Option_::NetworkInformationServers(ref val) => {
3859                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3860                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3861                    encoder, offset + 8, _depth
3862                )
3863            }
3864            Option_::NetworkTimeProtocolServers(ref val) => {
3865                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3866                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3867                    encoder, offset + 8, _depth
3868                )
3869            }
3870            Option_::VendorSpecificInformation(ref val) => {
3871                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<u8, 255>, D>(
3872                    <fidl::encoding::Vector<u8, 255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3873                    encoder, offset + 8, _depth
3874                )
3875            }
3876            Option_::NetbiosOverTcpipNameServer(ref val) => {
3877                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3878                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3879                    encoder, offset + 8, _depth
3880                )
3881            }
3882            Option_::NetbiosOverTcpipDatagramDistributionServer(ref val) => {
3883                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3884                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3885                    encoder, offset + 8, _depth
3886                )
3887            }
3888            Option_::NetbiosOverTcpipNodeType(ref val) => {
3889                fidl::encoding::encode_in_envelope::<NodeTypes, D>(
3890                    <NodeTypes as fidl::encoding::ValueTypeMarker>::borrow(val),
3891                    encoder, offset + 8, _depth
3892                )
3893            }
3894            Option_::NetbiosOverTcpipScope(ref val) => {
3895                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3896                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3897                    encoder, offset + 8, _depth
3898                )
3899            }
3900            Option_::XWindowSystemFontServer(ref val) => {
3901                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3902                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3903                    encoder, offset + 8, _depth
3904                )
3905            }
3906            Option_::XWindowSystemDisplayManager(ref val) => {
3907                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3908                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3909                    encoder, offset + 8, _depth
3910                )
3911            }
3912            Option_::NetworkInformationServicePlusDomain(ref val) => {
3913                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3914                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3915                    encoder, offset + 8, _depth
3916                )
3917            }
3918            Option_::NetworkInformationServicePlusServers(ref val) => {
3919                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3920                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3921                    encoder, offset + 8, _depth
3922                )
3923            }
3924            Option_::MobileIpHomeAgent(ref val) => {
3925                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3926                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3927                    encoder, offset + 8, _depth
3928                )
3929            }
3930            Option_::SmtpServer(ref val) => {
3931                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3932                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3933                    encoder, offset + 8, _depth
3934                )
3935            }
3936            Option_::Pop3Server(ref val) => {
3937                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3938                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3939                    encoder, offset + 8, _depth
3940                )
3941            }
3942            Option_::NntpServer(ref val) => {
3943                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3944                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3945                    encoder, offset + 8, _depth
3946                )
3947            }
3948            Option_::DefaultWwwServer(ref val) => {
3949                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3950                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3951                    encoder, offset + 8, _depth
3952                )
3953            }
3954            Option_::DefaultFingerServer(ref val) => {
3955                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3956                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3957                    encoder, offset + 8, _depth
3958                )
3959            }
3960            Option_::DefaultIrcServer(ref val) => {
3961                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3962                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3963                    encoder, offset + 8, _depth
3964                )
3965            }
3966            Option_::StreettalkServer(ref val) => {
3967                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3968                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3969                    encoder, offset + 8, _depth
3970                )
3971            }
3972            Option_::StreettalkDirectoryAssistanceServer(ref val) => {
3973                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D>(
3974                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
3975                    encoder, offset + 8, _depth
3976                )
3977            }
3978            Option_::OptionOverload(ref val) => {
3979                fidl::encoding::encode_in_envelope::<OptionOverloadValue, D>(
3980                    <OptionOverloadValue as fidl::encoding::ValueTypeMarker>::borrow(val),
3981                    encoder, offset + 8, _depth
3982                )
3983            }
3984            Option_::TftpServerName(ref val) => {
3985                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3986                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3987                    encoder, offset + 8, _depth
3988                )
3989            }
3990            Option_::BootfileName(ref val) => {
3991                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
3992                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
3993                    encoder, offset + 8, _depth
3994                )
3995            }
3996            Option_::MaxDhcpMessageSize(ref val) => {
3997                fidl::encoding::encode_in_envelope::<u16, D>(
3998                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
3999                    encoder, offset + 8, _depth
4000                )
4001            }
4002            Option_::RenewalTimeValue(ref val) => {
4003                fidl::encoding::encode_in_envelope::<u32, D>(
4004                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
4005                    encoder, offset + 8, _depth
4006                )
4007            }
4008            Option_::RebindingTimeValue(ref val) => {
4009                fidl::encoding::encode_in_envelope::<u32, D>(
4010                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
4011                    encoder, offset + 8, _depth
4012                )
4013            }
4014            Option_::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
4015        }
4016        }
4017    }
4018
4019    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Option_ {
4020        #[inline(always)]
4021        fn new_empty() -> Self {
4022            Self::__SourceBreaking { unknown_ordinal: 0 }
4023        }
4024
4025        #[inline]
4026        unsafe fn decode(
4027            &mut self,
4028            decoder: &mut fidl::encoding::Decoder<'_, D>,
4029            offset: usize,
4030            mut depth: fidl::encoding::Depth,
4031        ) -> fidl::Result<()> {
4032            decoder.debug_check_bounds::<Self>(offset);
4033            #[allow(unused_variables)]
4034            let next_out_of_line = decoder.next_out_of_line();
4035            let handles_before = decoder.remaining_handles();
4036            let (ordinal, inlined, num_bytes, num_handles) =
4037                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
4038
4039            let member_inline_size = match ordinal {
4040            1 => <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4041            2 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4042            3 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4043            4 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4044            5 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4045            6 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4046            7 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4047            8 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4048            9 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4049            10 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4050            11 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4051            12 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4052            13 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4053            14 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4054            15 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4055            16 => <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4056            17 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4057            18 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4058            19 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4059            20 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4060            21 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4061            22 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4062            23 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4063            24 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4064            25 => <fidl::encoding::Vector<u16, 127> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4065            26 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4066            27 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4067            28 => <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4068            29 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4069            30 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4070            31 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4071            32 => <fidl_fuchsia_net__common::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4072            33 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4073            34 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4074            35 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4075            36 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4076            37 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4077            38 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4078            39 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4079            40 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4080            41 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4081            42 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4082            43 => <fidl::encoding::Vector<u8, 255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4083            44 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4084            45 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4085            46 => <NodeTypes as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4086            47 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4087            48 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4088            49 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4089            50 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4090            51 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4091            52 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4092            53 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4093            54 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4094            55 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4095            56 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4096            57 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4097            58 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4098            59 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4099            60 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4100            61 => <OptionOverloadValue as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4101            62 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4102            63 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4103            64 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4104            65 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4105            66 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
4106            0 => return Err(fidl::Error::UnknownUnionTag),
4107            _ => num_bytes as usize,
4108        };
4109
4110            if inlined != (member_inline_size <= 4) {
4111                return Err(fidl::Error::InvalidInlineBitInEnvelope);
4112            }
4113            let _inner_offset;
4114            if inlined {
4115                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
4116                _inner_offset = offset + 8;
4117            } else {
4118                depth.increment()?;
4119                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4120            }
4121            match ordinal {
4122                1 => {
4123                    #[allow(irrefutable_let_patterns)]
4124                    if let Option_::SubnetMask(_) = self {
4125                        // Do nothing, read the value into the object
4126                    } else {
4127                        // Initialize `self` to the right variant
4128                        *self = Option_::SubnetMask(fidl::new_empty!(
4129                            fidl_fuchsia_net__common::Ipv4Address,
4130                            D
4131                        ));
4132                    }
4133                    #[allow(irrefutable_let_patterns)]
4134                    if let Option_::SubnetMask(ref mut val) = self {
4135                        fidl::decode!(
4136                            fidl_fuchsia_net__common::Ipv4Address,
4137                            D,
4138                            val,
4139                            decoder,
4140                            _inner_offset,
4141                            depth
4142                        )?;
4143                    } else {
4144                        unreachable!()
4145                    }
4146                }
4147                2 => {
4148                    #[allow(irrefutable_let_patterns)]
4149                    if let Option_::TimeOffset(_) = self {
4150                        // Do nothing, read the value into the object
4151                    } else {
4152                        // Initialize `self` to the right variant
4153                        *self = Option_::TimeOffset(fidl::new_empty!(i32, D));
4154                    }
4155                    #[allow(irrefutable_let_patterns)]
4156                    if let Option_::TimeOffset(ref mut val) = self {
4157                        fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
4158                    } else {
4159                        unreachable!()
4160                    }
4161                }
4162                3 => {
4163                    #[allow(irrefutable_let_patterns)]
4164                    if let Option_::Router(_) = self {
4165                        // Do nothing, read the value into the object
4166                    } else {
4167                        // Initialize `self` to the right variant
4168                        *self = Option_::Router(
4169                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4170                        );
4171                    }
4172                    #[allow(irrefutable_let_patterns)]
4173                    if let Option_::Router(ref mut val) = self {
4174                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4175                    } else {
4176                        unreachable!()
4177                    }
4178                }
4179                4 => {
4180                    #[allow(irrefutable_let_patterns)]
4181                    if let Option_::TimeServer(_) = self {
4182                        // Do nothing, read the value into the object
4183                    } else {
4184                        // Initialize `self` to the right variant
4185                        *self = Option_::TimeServer(
4186                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4187                        );
4188                    }
4189                    #[allow(irrefutable_let_patterns)]
4190                    if let Option_::TimeServer(ref mut val) = self {
4191                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4192                    } else {
4193                        unreachable!()
4194                    }
4195                }
4196                5 => {
4197                    #[allow(irrefutable_let_patterns)]
4198                    if let Option_::NameServer(_) = self {
4199                        // Do nothing, read the value into the object
4200                    } else {
4201                        // Initialize `self` to the right variant
4202                        *self = Option_::NameServer(
4203                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4204                        );
4205                    }
4206                    #[allow(irrefutable_let_patterns)]
4207                    if let Option_::NameServer(ref mut val) = self {
4208                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4209                    } else {
4210                        unreachable!()
4211                    }
4212                }
4213                6 => {
4214                    #[allow(irrefutable_let_patterns)]
4215                    if let Option_::DomainNameServer(_) = self {
4216                        // Do nothing, read the value into the object
4217                    } else {
4218                        // Initialize `self` to the right variant
4219                        *self = Option_::DomainNameServer(
4220                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4221                        );
4222                    }
4223                    #[allow(irrefutable_let_patterns)]
4224                    if let Option_::DomainNameServer(ref mut val) = self {
4225                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4226                    } else {
4227                        unreachable!()
4228                    }
4229                }
4230                7 => {
4231                    #[allow(irrefutable_let_patterns)]
4232                    if let Option_::LogServer(_) = self {
4233                        // Do nothing, read the value into the object
4234                    } else {
4235                        // Initialize `self` to the right variant
4236                        *self = Option_::LogServer(
4237                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4238                        );
4239                    }
4240                    #[allow(irrefutable_let_patterns)]
4241                    if let Option_::LogServer(ref mut val) = self {
4242                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4243                    } else {
4244                        unreachable!()
4245                    }
4246                }
4247                8 => {
4248                    #[allow(irrefutable_let_patterns)]
4249                    if let Option_::CookieServer(_) = self {
4250                        // Do nothing, read the value into the object
4251                    } else {
4252                        // Initialize `self` to the right variant
4253                        *self = Option_::CookieServer(
4254                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4255                        );
4256                    }
4257                    #[allow(irrefutable_let_patterns)]
4258                    if let Option_::CookieServer(ref mut val) = self {
4259                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4260                    } else {
4261                        unreachable!()
4262                    }
4263                }
4264                9 => {
4265                    #[allow(irrefutable_let_patterns)]
4266                    if let Option_::LprServer(_) = self {
4267                        // Do nothing, read the value into the object
4268                    } else {
4269                        // Initialize `self` to the right variant
4270                        *self = Option_::LprServer(
4271                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4272                        );
4273                    }
4274                    #[allow(irrefutable_let_patterns)]
4275                    if let Option_::LprServer(ref mut val) = self {
4276                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4277                    } else {
4278                        unreachable!()
4279                    }
4280                }
4281                10 => {
4282                    #[allow(irrefutable_let_patterns)]
4283                    if let Option_::ImpressServer(_) = self {
4284                        // Do nothing, read the value into the object
4285                    } else {
4286                        // Initialize `self` to the right variant
4287                        *self = Option_::ImpressServer(
4288                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4289                        );
4290                    }
4291                    #[allow(irrefutable_let_patterns)]
4292                    if let Option_::ImpressServer(ref mut val) = self {
4293                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4294                    } else {
4295                        unreachable!()
4296                    }
4297                }
4298                11 => {
4299                    #[allow(irrefutable_let_patterns)]
4300                    if let Option_::ResourceLocationServer(_) = self {
4301                        // Do nothing, read the value into the object
4302                    } else {
4303                        // Initialize `self` to the right variant
4304                        *self = Option_::ResourceLocationServer(
4305                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4306                        );
4307                    }
4308                    #[allow(irrefutable_let_patterns)]
4309                    if let Option_::ResourceLocationServer(ref mut val) = self {
4310                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4311                    } else {
4312                        unreachable!()
4313                    }
4314                }
4315                12 => {
4316                    #[allow(irrefutable_let_patterns)]
4317                    if let Option_::HostName(_) = self {
4318                        // Do nothing, read the value into the object
4319                    } else {
4320                        // Initialize `self` to the right variant
4321                        *self = Option_::HostName(fidl::new_empty!(
4322                            fidl::encoding::BoundedString<255>,
4323                            D
4324                        ));
4325                    }
4326                    #[allow(irrefutable_let_patterns)]
4327                    if let Option_::HostName(ref mut val) = self {
4328                        fidl::decode!(
4329                            fidl::encoding::BoundedString<255>,
4330                            D,
4331                            val,
4332                            decoder,
4333                            _inner_offset,
4334                            depth
4335                        )?;
4336                    } else {
4337                        unreachable!()
4338                    }
4339                }
4340                13 => {
4341                    #[allow(irrefutable_let_patterns)]
4342                    if let Option_::BootFileSize(_) = self {
4343                        // Do nothing, read the value into the object
4344                    } else {
4345                        // Initialize `self` to the right variant
4346                        *self = Option_::BootFileSize(fidl::new_empty!(u16, D));
4347                    }
4348                    #[allow(irrefutable_let_patterns)]
4349                    if let Option_::BootFileSize(ref mut val) = self {
4350                        fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
4351                    } else {
4352                        unreachable!()
4353                    }
4354                }
4355                14 => {
4356                    #[allow(irrefutable_let_patterns)]
4357                    if let Option_::MeritDumpFile(_) = self {
4358                        // Do nothing, read the value into the object
4359                    } else {
4360                        // Initialize `self` to the right variant
4361                        *self = Option_::MeritDumpFile(fidl::new_empty!(
4362                            fidl::encoding::BoundedString<255>,
4363                            D
4364                        ));
4365                    }
4366                    #[allow(irrefutable_let_patterns)]
4367                    if let Option_::MeritDumpFile(ref mut val) = self {
4368                        fidl::decode!(
4369                            fidl::encoding::BoundedString<255>,
4370                            D,
4371                            val,
4372                            decoder,
4373                            _inner_offset,
4374                            depth
4375                        )?;
4376                    } else {
4377                        unreachable!()
4378                    }
4379                }
4380                15 => {
4381                    #[allow(irrefutable_let_patterns)]
4382                    if let Option_::DomainName(_) = self {
4383                        // Do nothing, read the value into the object
4384                    } else {
4385                        // Initialize `self` to the right variant
4386                        *self = Option_::DomainName(fidl::new_empty!(
4387                            fidl::encoding::BoundedString<255>,
4388                            D
4389                        ));
4390                    }
4391                    #[allow(irrefutable_let_patterns)]
4392                    if let Option_::DomainName(ref mut val) = self {
4393                        fidl::decode!(
4394                            fidl::encoding::BoundedString<255>,
4395                            D,
4396                            val,
4397                            decoder,
4398                            _inner_offset,
4399                            depth
4400                        )?;
4401                    } else {
4402                        unreachable!()
4403                    }
4404                }
4405                16 => {
4406                    #[allow(irrefutable_let_patterns)]
4407                    if let Option_::SwapServer(_) = self {
4408                        // Do nothing, read the value into the object
4409                    } else {
4410                        // Initialize `self` to the right variant
4411                        *self = Option_::SwapServer(fidl::new_empty!(
4412                            fidl_fuchsia_net__common::Ipv4Address,
4413                            D
4414                        ));
4415                    }
4416                    #[allow(irrefutable_let_patterns)]
4417                    if let Option_::SwapServer(ref mut val) = self {
4418                        fidl::decode!(
4419                            fidl_fuchsia_net__common::Ipv4Address,
4420                            D,
4421                            val,
4422                            decoder,
4423                            _inner_offset,
4424                            depth
4425                        )?;
4426                    } else {
4427                        unreachable!()
4428                    }
4429                }
4430                17 => {
4431                    #[allow(irrefutable_let_patterns)]
4432                    if let Option_::RootPath(_) = self {
4433                        // Do nothing, read the value into the object
4434                    } else {
4435                        // Initialize `self` to the right variant
4436                        *self = Option_::RootPath(fidl::new_empty!(
4437                            fidl::encoding::BoundedString<255>,
4438                            D
4439                        ));
4440                    }
4441                    #[allow(irrefutable_let_patterns)]
4442                    if let Option_::RootPath(ref mut val) = self {
4443                        fidl::decode!(
4444                            fidl::encoding::BoundedString<255>,
4445                            D,
4446                            val,
4447                            decoder,
4448                            _inner_offset,
4449                            depth
4450                        )?;
4451                    } else {
4452                        unreachable!()
4453                    }
4454                }
4455                18 => {
4456                    #[allow(irrefutable_let_patterns)]
4457                    if let Option_::ExtensionsPath(_) = self {
4458                        // Do nothing, read the value into the object
4459                    } else {
4460                        // Initialize `self` to the right variant
4461                        *self = Option_::ExtensionsPath(fidl::new_empty!(
4462                            fidl::encoding::BoundedString<255>,
4463                            D
4464                        ));
4465                    }
4466                    #[allow(irrefutable_let_patterns)]
4467                    if let Option_::ExtensionsPath(ref mut val) = self {
4468                        fidl::decode!(
4469                            fidl::encoding::BoundedString<255>,
4470                            D,
4471                            val,
4472                            decoder,
4473                            _inner_offset,
4474                            depth
4475                        )?;
4476                    } else {
4477                        unreachable!()
4478                    }
4479                }
4480                19 => {
4481                    #[allow(irrefutable_let_patterns)]
4482                    if let Option_::IpForwarding(_) = self {
4483                        // Do nothing, read the value into the object
4484                    } else {
4485                        // Initialize `self` to the right variant
4486                        *self = Option_::IpForwarding(fidl::new_empty!(bool, D));
4487                    }
4488                    #[allow(irrefutable_let_patterns)]
4489                    if let Option_::IpForwarding(ref mut val) = self {
4490                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
4491                    } else {
4492                        unreachable!()
4493                    }
4494                }
4495                20 => {
4496                    #[allow(irrefutable_let_patterns)]
4497                    if let Option_::NonLocalSourceRouting(_) = self {
4498                        // Do nothing, read the value into the object
4499                    } else {
4500                        // Initialize `self` to the right variant
4501                        *self = Option_::NonLocalSourceRouting(fidl::new_empty!(bool, D));
4502                    }
4503                    #[allow(irrefutable_let_patterns)]
4504                    if let Option_::NonLocalSourceRouting(ref mut val) = self {
4505                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
4506                    } else {
4507                        unreachable!()
4508                    }
4509                }
4510                21 => {
4511                    #[allow(irrefutable_let_patterns)]
4512                    if let Option_::PolicyFilter(_) = self {
4513                        // Do nothing, read the value into the object
4514                    } else {
4515                        // Initialize `self` to the right variant
4516                        *self = Option_::PolicyFilter(
4517                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4518                        );
4519                    }
4520                    #[allow(irrefutable_let_patterns)]
4521                    if let Option_::PolicyFilter(ref mut val) = self {
4522                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4523                    } else {
4524                        unreachable!()
4525                    }
4526                }
4527                22 => {
4528                    #[allow(irrefutable_let_patterns)]
4529                    if let Option_::MaxDatagramReassemblySize(_) = self {
4530                        // Do nothing, read the value into the object
4531                    } else {
4532                        // Initialize `self` to the right variant
4533                        *self = Option_::MaxDatagramReassemblySize(fidl::new_empty!(u16, D));
4534                    }
4535                    #[allow(irrefutable_let_patterns)]
4536                    if let Option_::MaxDatagramReassemblySize(ref mut val) = self {
4537                        fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
4538                    } else {
4539                        unreachable!()
4540                    }
4541                }
4542                23 => {
4543                    #[allow(irrefutable_let_patterns)]
4544                    if let Option_::DefaultIpTtl(_) = self {
4545                        // Do nothing, read the value into the object
4546                    } else {
4547                        // Initialize `self` to the right variant
4548                        *self = Option_::DefaultIpTtl(fidl::new_empty!(u8, D));
4549                    }
4550                    #[allow(irrefutable_let_patterns)]
4551                    if let Option_::DefaultIpTtl(ref mut val) = self {
4552                        fidl::decode!(u8, D, val, decoder, _inner_offset, depth)?;
4553                    } else {
4554                        unreachable!()
4555                    }
4556                }
4557                24 => {
4558                    #[allow(irrefutable_let_patterns)]
4559                    if let Option_::PathMtuAgingTimeout(_) = self {
4560                        // Do nothing, read the value into the object
4561                    } else {
4562                        // Initialize `self` to the right variant
4563                        *self = Option_::PathMtuAgingTimeout(fidl::new_empty!(u32, D));
4564                    }
4565                    #[allow(irrefutable_let_patterns)]
4566                    if let Option_::PathMtuAgingTimeout(ref mut val) = self {
4567                        fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
4568                    } else {
4569                        unreachable!()
4570                    }
4571                }
4572                25 => {
4573                    #[allow(irrefutable_let_patterns)]
4574                    if let Option_::PathMtuPlateauTable(_) = self {
4575                        // Do nothing, read the value into the object
4576                    } else {
4577                        // Initialize `self` to the right variant
4578                        *self = Option_::PathMtuPlateauTable(
4579                            fidl::new_empty!(fidl::encoding::Vector<u16, 127>, D),
4580                        );
4581                    }
4582                    #[allow(irrefutable_let_patterns)]
4583                    if let Option_::PathMtuPlateauTable(ref mut val) = self {
4584                        fidl::decode!(fidl::encoding::Vector<u16, 127>, D, val, decoder, _inner_offset, depth)?;
4585                    } else {
4586                        unreachable!()
4587                    }
4588                }
4589                26 => {
4590                    #[allow(irrefutable_let_patterns)]
4591                    if let Option_::InterfaceMtu(_) = self {
4592                        // Do nothing, read the value into the object
4593                    } else {
4594                        // Initialize `self` to the right variant
4595                        *self = Option_::InterfaceMtu(fidl::new_empty!(u16, D));
4596                    }
4597                    #[allow(irrefutable_let_patterns)]
4598                    if let Option_::InterfaceMtu(ref mut val) = self {
4599                        fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
4600                    } else {
4601                        unreachable!()
4602                    }
4603                }
4604                27 => {
4605                    #[allow(irrefutable_let_patterns)]
4606                    if let Option_::AllSubnetsLocal(_) = self {
4607                        // Do nothing, read the value into the object
4608                    } else {
4609                        // Initialize `self` to the right variant
4610                        *self = Option_::AllSubnetsLocal(fidl::new_empty!(bool, D));
4611                    }
4612                    #[allow(irrefutable_let_patterns)]
4613                    if let Option_::AllSubnetsLocal(ref mut val) = self {
4614                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
4615                    } else {
4616                        unreachable!()
4617                    }
4618                }
4619                28 => {
4620                    #[allow(irrefutable_let_patterns)]
4621                    if let Option_::BroadcastAddress(_) = self {
4622                        // Do nothing, read the value into the object
4623                    } else {
4624                        // Initialize `self` to the right variant
4625                        *self = Option_::BroadcastAddress(fidl::new_empty!(
4626                            fidl_fuchsia_net__common::Ipv4Address,
4627                            D
4628                        ));
4629                    }
4630                    #[allow(irrefutable_let_patterns)]
4631                    if let Option_::BroadcastAddress(ref mut val) = self {
4632                        fidl::decode!(
4633                            fidl_fuchsia_net__common::Ipv4Address,
4634                            D,
4635                            val,
4636                            decoder,
4637                            _inner_offset,
4638                            depth
4639                        )?;
4640                    } else {
4641                        unreachable!()
4642                    }
4643                }
4644                29 => {
4645                    #[allow(irrefutable_let_patterns)]
4646                    if let Option_::PerformMaskDiscovery(_) = self {
4647                        // Do nothing, read the value into the object
4648                    } else {
4649                        // Initialize `self` to the right variant
4650                        *self = Option_::PerformMaskDiscovery(fidl::new_empty!(bool, D));
4651                    }
4652                    #[allow(irrefutable_let_patterns)]
4653                    if let Option_::PerformMaskDiscovery(ref mut val) = self {
4654                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
4655                    } else {
4656                        unreachable!()
4657                    }
4658                }
4659                30 => {
4660                    #[allow(irrefutable_let_patterns)]
4661                    if let Option_::MaskSupplier(_) = self {
4662                        // Do nothing, read the value into the object
4663                    } else {
4664                        // Initialize `self` to the right variant
4665                        *self = Option_::MaskSupplier(fidl::new_empty!(bool, D));
4666                    }
4667                    #[allow(irrefutable_let_patterns)]
4668                    if let Option_::MaskSupplier(ref mut val) = self {
4669                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
4670                    } else {
4671                        unreachable!()
4672                    }
4673                }
4674                31 => {
4675                    #[allow(irrefutable_let_patterns)]
4676                    if let Option_::PerformRouterDiscovery(_) = self {
4677                        // Do nothing, read the value into the object
4678                    } else {
4679                        // Initialize `self` to the right variant
4680                        *self = Option_::PerformRouterDiscovery(fidl::new_empty!(bool, D));
4681                    }
4682                    #[allow(irrefutable_let_patterns)]
4683                    if let Option_::PerformRouterDiscovery(ref mut val) = self {
4684                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
4685                    } else {
4686                        unreachable!()
4687                    }
4688                }
4689                32 => {
4690                    #[allow(irrefutable_let_patterns)]
4691                    if let Option_::RouterSolicitationAddress(_) = self {
4692                        // Do nothing, read the value into the object
4693                    } else {
4694                        // Initialize `self` to the right variant
4695                        *self = Option_::RouterSolicitationAddress(fidl::new_empty!(
4696                            fidl_fuchsia_net__common::Ipv4Address,
4697                            D
4698                        ));
4699                    }
4700                    #[allow(irrefutable_let_patterns)]
4701                    if let Option_::RouterSolicitationAddress(ref mut val) = self {
4702                        fidl::decode!(
4703                            fidl_fuchsia_net__common::Ipv4Address,
4704                            D,
4705                            val,
4706                            decoder,
4707                            _inner_offset,
4708                            depth
4709                        )?;
4710                    } else {
4711                        unreachable!()
4712                    }
4713                }
4714                33 => {
4715                    #[allow(irrefutable_let_patterns)]
4716                    if let Option_::StaticRoute(_) = self {
4717                        // Do nothing, read the value into the object
4718                    } else {
4719                        // Initialize `self` to the right variant
4720                        *self = Option_::StaticRoute(
4721                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4722                        );
4723                    }
4724                    #[allow(irrefutable_let_patterns)]
4725                    if let Option_::StaticRoute(ref mut val) = self {
4726                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4727                    } else {
4728                        unreachable!()
4729                    }
4730                }
4731                34 => {
4732                    #[allow(irrefutable_let_patterns)]
4733                    if let Option_::TrailerEncapsulation(_) = self {
4734                        // Do nothing, read the value into the object
4735                    } else {
4736                        // Initialize `self` to the right variant
4737                        *self = Option_::TrailerEncapsulation(fidl::new_empty!(bool, D));
4738                    }
4739                    #[allow(irrefutable_let_patterns)]
4740                    if let Option_::TrailerEncapsulation(ref mut val) = self {
4741                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
4742                    } else {
4743                        unreachable!()
4744                    }
4745                }
4746                35 => {
4747                    #[allow(irrefutable_let_patterns)]
4748                    if let Option_::ArpCacheTimeout(_) = self {
4749                        // Do nothing, read the value into the object
4750                    } else {
4751                        // Initialize `self` to the right variant
4752                        *self = Option_::ArpCacheTimeout(fidl::new_empty!(u32, D));
4753                    }
4754                    #[allow(irrefutable_let_patterns)]
4755                    if let Option_::ArpCacheTimeout(ref mut val) = self {
4756                        fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
4757                    } else {
4758                        unreachable!()
4759                    }
4760                }
4761                36 => {
4762                    #[allow(irrefutable_let_patterns)]
4763                    if let Option_::EthernetEncapsulation(_) = self {
4764                        // Do nothing, read the value into the object
4765                    } else {
4766                        // Initialize `self` to the right variant
4767                        *self = Option_::EthernetEncapsulation(fidl::new_empty!(bool, D));
4768                    }
4769                    #[allow(irrefutable_let_patterns)]
4770                    if let Option_::EthernetEncapsulation(ref mut val) = self {
4771                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
4772                    } else {
4773                        unreachable!()
4774                    }
4775                }
4776                37 => {
4777                    #[allow(irrefutable_let_patterns)]
4778                    if let Option_::TcpDefaultTtl(_) = self {
4779                        // Do nothing, read the value into the object
4780                    } else {
4781                        // Initialize `self` to the right variant
4782                        *self = Option_::TcpDefaultTtl(fidl::new_empty!(u8, D));
4783                    }
4784                    #[allow(irrefutable_let_patterns)]
4785                    if let Option_::TcpDefaultTtl(ref mut val) = self {
4786                        fidl::decode!(u8, D, val, decoder, _inner_offset, depth)?;
4787                    } else {
4788                        unreachable!()
4789                    }
4790                }
4791                38 => {
4792                    #[allow(irrefutable_let_patterns)]
4793                    if let Option_::TcpKeepaliveInterval(_) = self {
4794                        // Do nothing, read the value into the object
4795                    } else {
4796                        // Initialize `self` to the right variant
4797                        *self = Option_::TcpKeepaliveInterval(fidl::new_empty!(u32, D));
4798                    }
4799                    #[allow(irrefutable_let_patterns)]
4800                    if let Option_::TcpKeepaliveInterval(ref mut val) = self {
4801                        fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
4802                    } else {
4803                        unreachable!()
4804                    }
4805                }
4806                39 => {
4807                    #[allow(irrefutable_let_patterns)]
4808                    if let Option_::TcpKeepaliveGarbage(_) = self {
4809                        // Do nothing, read the value into the object
4810                    } else {
4811                        // Initialize `self` to the right variant
4812                        *self = Option_::TcpKeepaliveGarbage(fidl::new_empty!(bool, D));
4813                    }
4814                    #[allow(irrefutable_let_patterns)]
4815                    if let Option_::TcpKeepaliveGarbage(ref mut val) = self {
4816                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
4817                    } else {
4818                        unreachable!()
4819                    }
4820                }
4821                40 => {
4822                    #[allow(irrefutable_let_patterns)]
4823                    if let Option_::NetworkInformationServiceDomain(_) = self {
4824                        // Do nothing, read the value into the object
4825                    } else {
4826                        // Initialize `self` to the right variant
4827                        *self = Option_::NetworkInformationServiceDomain(fidl::new_empty!(
4828                            fidl::encoding::BoundedString<255>,
4829                            D
4830                        ));
4831                    }
4832                    #[allow(irrefutable_let_patterns)]
4833                    if let Option_::NetworkInformationServiceDomain(ref mut val) = self {
4834                        fidl::decode!(
4835                            fidl::encoding::BoundedString<255>,
4836                            D,
4837                            val,
4838                            decoder,
4839                            _inner_offset,
4840                            depth
4841                        )?;
4842                    } else {
4843                        unreachable!()
4844                    }
4845                }
4846                41 => {
4847                    #[allow(irrefutable_let_patterns)]
4848                    if let Option_::NetworkInformationServers(_) = self {
4849                        // Do nothing, read the value into the object
4850                    } else {
4851                        // Initialize `self` to the right variant
4852                        *self = Option_::NetworkInformationServers(
4853                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4854                        );
4855                    }
4856                    #[allow(irrefutable_let_patterns)]
4857                    if let Option_::NetworkInformationServers(ref mut val) = self {
4858                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4859                    } else {
4860                        unreachable!()
4861                    }
4862                }
4863                42 => {
4864                    #[allow(irrefutable_let_patterns)]
4865                    if let Option_::NetworkTimeProtocolServers(_) = self {
4866                        // Do nothing, read the value into the object
4867                    } else {
4868                        // Initialize `self` to the right variant
4869                        *self = Option_::NetworkTimeProtocolServers(
4870                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4871                        );
4872                    }
4873                    #[allow(irrefutable_let_patterns)]
4874                    if let Option_::NetworkTimeProtocolServers(ref mut val) = self {
4875                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4876                    } else {
4877                        unreachable!()
4878                    }
4879                }
4880                43 => {
4881                    #[allow(irrefutable_let_patterns)]
4882                    if let Option_::VendorSpecificInformation(_) = self {
4883                        // Do nothing, read the value into the object
4884                    } else {
4885                        // Initialize `self` to the right variant
4886                        *self = Option_::VendorSpecificInformation(
4887                            fidl::new_empty!(fidl::encoding::Vector<u8, 255>, D),
4888                        );
4889                    }
4890                    #[allow(irrefutable_let_patterns)]
4891                    if let Option_::VendorSpecificInformation(ref mut val) = self {
4892                        fidl::decode!(fidl::encoding::Vector<u8, 255>, D, val, decoder, _inner_offset, depth)?;
4893                    } else {
4894                        unreachable!()
4895                    }
4896                }
4897                44 => {
4898                    #[allow(irrefutable_let_patterns)]
4899                    if let Option_::NetbiosOverTcpipNameServer(_) = self {
4900                        // Do nothing, read the value into the object
4901                    } else {
4902                        // Initialize `self` to the right variant
4903                        *self = Option_::NetbiosOverTcpipNameServer(
4904                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4905                        );
4906                    }
4907                    #[allow(irrefutable_let_patterns)]
4908                    if let Option_::NetbiosOverTcpipNameServer(ref mut val) = self {
4909                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4910                    } else {
4911                        unreachable!()
4912                    }
4913                }
4914                45 => {
4915                    #[allow(irrefutable_let_patterns)]
4916                    if let Option_::NetbiosOverTcpipDatagramDistributionServer(_) = self {
4917                        // Do nothing, read the value into the object
4918                    } else {
4919                        // Initialize `self` to the right variant
4920                        *self = Option_::NetbiosOverTcpipDatagramDistributionServer(
4921                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4922                        );
4923                    }
4924                    #[allow(irrefutable_let_patterns)]
4925                    if let Option_::NetbiosOverTcpipDatagramDistributionServer(ref mut val) = self {
4926                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4927                    } else {
4928                        unreachable!()
4929                    }
4930                }
4931                46 => {
4932                    #[allow(irrefutable_let_patterns)]
4933                    if let Option_::NetbiosOverTcpipNodeType(_) = self {
4934                        // Do nothing, read the value into the object
4935                    } else {
4936                        // Initialize `self` to the right variant
4937                        *self = Option_::NetbiosOverTcpipNodeType(fidl::new_empty!(NodeTypes, D));
4938                    }
4939                    #[allow(irrefutable_let_patterns)]
4940                    if let Option_::NetbiosOverTcpipNodeType(ref mut val) = self {
4941                        fidl::decode!(NodeTypes, D, val, decoder, _inner_offset, depth)?;
4942                    } else {
4943                        unreachable!()
4944                    }
4945                }
4946                47 => {
4947                    #[allow(irrefutable_let_patterns)]
4948                    if let Option_::NetbiosOverTcpipScope(_) = self {
4949                        // Do nothing, read the value into the object
4950                    } else {
4951                        // Initialize `self` to the right variant
4952                        *self = Option_::NetbiosOverTcpipScope(fidl::new_empty!(
4953                            fidl::encoding::BoundedString<255>,
4954                            D
4955                        ));
4956                    }
4957                    #[allow(irrefutable_let_patterns)]
4958                    if let Option_::NetbiosOverTcpipScope(ref mut val) = self {
4959                        fidl::decode!(
4960                            fidl::encoding::BoundedString<255>,
4961                            D,
4962                            val,
4963                            decoder,
4964                            _inner_offset,
4965                            depth
4966                        )?;
4967                    } else {
4968                        unreachable!()
4969                    }
4970                }
4971                48 => {
4972                    #[allow(irrefutable_let_patterns)]
4973                    if let Option_::XWindowSystemFontServer(_) = self {
4974                        // Do nothing, read the value into the object
4975                    } else {
4976                        // Initialize `self` to the right variant
4977                        *self = Option_::XWindowSystemFontServer(
4978                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4979                        );
4980                    }
4981                    #[allow(irrefutable_let_patterns)]
4982                    if let Option_::XWindowSystemFontServer(ref mut val) = self {
4983                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
4984                    } else {
4985                        unreachable!()
4986                    }
4987                }
4988                49 => {
4989                    #[allow(irrefutable_let_patterns)]
4990                    if let Option_::XWindowSystemDisplayManager(_) = self {
4991                        // Do nothing, read the value into the object
4992                    } else {
4993                        // Initialize `self` to the right variant
4994                        *self = Option_::XWindowSystemDisplayManager(
4995                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
4996                        );
4997                    }
4998                    #[allow(irrefutable_let_patterns)]
4999                    if let Option_::XWindowSystemDisplayManager(ref mut val) = self {
5000                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5001                    } else {
5002                        unreachable!()
5003                    }
5004                }
5005                50 => {
5006                    #[allow(irrefutable_let_patterns)]
5007                    if let Option_::NetworkInformationServicePlusDomain(_) = self {
5008                        // Do nothing, read the value into the object
5009                    } else {
5010                        // Initialize `self` to the right variant
5011                        *self = Option_::NetworkInformationServicePlusDomain(fidl::new_empty!(
5012                            fidl::encoding::BoundedString<255>,
5013                            D
5014                        ));
5015                    }
5016                    #[allow(irrefutable_let_patterns)]
5017                    if let Option_::NetworkInformationServicePlusDomain(ref mut val) = self {
5018                        fidl::decode!(
5019                            fidl::encoding::BoundedString<255>,
5020                            D,
5021                            val,
5022                            decoder,
5023                            _inner_offset,
5024                            depth
5025                        )?;
5026                    } else {
5027                        unreachable!()
5028                    }
5029                }
5030                51 => {
5031                    #[allow(irrefutable_let_patterns)]
5032                    if let Option_::NetworkInformationServicePlusServers(_) = self {
5033                        // Do nothing, read the value into the object
5034                    } else {
5035                        // Initialize `self` to the right variant
5036                        *self = Option_::NetworkInformationServicePlusServers(
5037                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5038                        );
5039                    }
5040                    #[allow(irrefutable_let_patterns)]
5041                    if let Option_::NetworkInformationServicePlusServers(ref mut val) = self {
5042                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5043                    } else {
5044                        unreachable!()
5045                    }
5046                }
5047                52 => {
5048                    #[allow(irrefutable_let_patterns)]
5049                    if let Option_::MobileIpHomeAgent(_) = self {
5050                        // Do nothing, read the value into the object
5051                    } else {
5052                        // Initialize `self` to the right variant
5053                        *self = Option_::MobileIpHomeAgent(
5054                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5055                        );
5056                    }
5057                    #[allow(irrefutable_let_patterns)]
5058                    if let Option_::MobileIpHomeAgent(ref mut val) = self {
5059                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5060                    } else {
5061                        unreachable!()
5062                    }
5063                }
5064                53 => {
5065                    #[allow(irrefutable_let_patterns)]
5066                    if let Option_::SmtpServer(_) = self {
5067                        // Do nothing, read the value into the object
5068                    } else {
5069                        // Initialize `self` to the right variant
5070                        *self = Option_::SmtpServer(
5071                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5072                        );
5073                    }
5074                    #[allow(irrefutable_let_patterns)]
5075                    if let Option_::SmtpServer(ref mut val) = self {
5076                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5077                    } else {
5078                        unreachable!()
5079                    }
5080                }
5081                54 => {
5082                    #[allow(irrefutable_let_patterns)]
5083                    if let Option_::Pop3Server(_) = self {
5084                        // Do nothing, read the value into the object
5085                    } else {
5086                        // Initialize `self` to the right variant
5087                        *self = Option_::Pop3Server(
5088                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5089                        );
5090                    }
5091                    #[allow(irrefutable_let_patterns)]
5092                    if let Option_::Pop3Server(ref mut val) = self {
5093                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5094                    } else {
5095                        unreachable!()
5096                    }
5097                }
5098                55 => {
5099                    #[allow(irrefutable_let_patterns)]
5100                    if let Option_::NntpServer(_) = self {
5101                        // Do nothing, read the value into the object
5102                    } else {
5103                        // Initialize `self` to the right variant
5104                        *self = Option_::NntpServer(
5105                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5106                        );
5107                    }
5108                    #[allow(irrefutable_let_patterns)]
5109                    if let Option_::NntpServer(ref mut val) = self {
5110                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5111                    } else {
5112                        unreachable!()
5113                    }
5114                }
5115                56 => {
5116                    #[allow(irrefutable_let_patterns)]
5117                    if let Option_::DefaultWwwServer(_) = self {
5118                        // Do nothing, read the value into the object
5119                    } else {
5120                        // Initialize `self` to the right variant
5121                        *self = Option_::DefaultWwwServer(
5122                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5123                        );
5124                    }
5125                    #[allow(irrefutable_let_patterns)]
5126                    if let Option_::DefaultWwwServer(ref mut val) = self {
5127                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5128                    } else {
5129                        unreachable!()
5130                    }
5131                }
5132                57 => {
5133                    #[allow(irrefutable_let_patterns)]
5134                    if let Option_::DefaultFingerServer(_) = self {
5135                        // Do nothing, read the value into the object
5136                    } else {
5137                        // Initialize `self` to the right variant
5138                        *self = Option_::DefaultFingerServer(
5139                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5140                        );
5141                    }
5142                    #[allow(irrefutable_let_patterns)]
5143                    if let Option_::DefaultFingerServer(ref mut val) = self {
5144                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5145                    } else {
5146                        unreachable!()
5147                    }
5148                }
5149                58 => {
5150                    #[allow(irrefutable_let_patterns)]
5151                    if let Option_::DefaultIrcServer(_) = self {
5152                        // Do nothing, read the value into the object
5153                    } else {
5154                        // Initialize `self` to the right variant
5155                        *self = Option_::DefaultIrcServer(
5156                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5157                        );
5158                    }
5159                    #[allow(irrefutable_let_patterns)]
5160                    if let Option_::DefaultIrcServer(ref mut val) = self {
5161                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5162                    } else {
5163                        unreachable!()
5164                    }
5165                }
5166                59 => {
5167                    #[allow(irrefutable_let_patterns)]
5168                    if let Option_::StreettalkServer(_) = self {
5169                        // Do nothing, read the value into the object
5170                    } else {
5171                        // Initialize `self` to the right variant
5172                        *self = Option_::StreettalkServer(
5173                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5174                        );
5175                    }
5176                    #[allow(irrefutable_let_patterns)]
5177                    if let Option_::StreettalkServer(ref mut val) = self {
5178                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5179                    } else {
5180                        unreachable!()
5181                    }
5182                }
5183                60 => {
5184                    #[allow(irrefutable_let_patterns)]
5185                    if let Option_::StreettalkDirectoryAssistanceServer(_) = self {
5186                        // Do nothing, read the value into the object
5187                    } else {
5188                        // Initialize `self` to the right variant
5189                        *self = Option_::StreettalkDirectoryAssistanceServer(
5190                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D),
5191                        );
5192                    }
5193                    #[allow(irrefutable_let_patterns)]
5194                    if let Option_::StreettalkDirectoryAssistanceServer(ref mut val) = self {
5195                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
5196                    } else {
5197                        unreachable!()
5198                    }
5199                }
5200                61 => {
5201                    #[allow(irrefutable_let_patterns)]
5202                    if let Option_::OptionOverload(_) = self {
5203                        // Do nothing, read the value into the object
5204                    } else {
5205                        // Initialize `self` to the right variant
5206                        *self = Option_::OptionOverload(fidl::new_empty!(OptionOverloadValue, D));
5207                    }
5208                    #[allow(irrefutable_let_patterns)]
5209                    if let Option_::OptionOverload(ref mut val) = self {
5210                        fidl::decode!(OptionOverloadValue, D, val, decoder, _inner_offset, depth)?;
5211                    } else {
5212                        unreachable!()
5213                    }
5214                }
5215                62 => {
5216                    #[allow(irrefutable_let_patterns)]
5217                    if let Option_::TftpServerName(_) = self {
5218                        // Do nothing, read the value into the object
5219                    } else {
5220                        // Initialize `self` to the right variant
5221                        *self = Option_::TftpServerName(fidl::new_empty!(
5222                            fidl::encoding::BoundedString<255>,
5223                            D
5224                        ));
5225                    }
5226                    #[allow(irrefutable_let_patterns)]
5227                    if let Option_::TftpServerName(ref mut val) = self {
5228                        fidl::decode!(
5229                            fidl::encoding::BoundedString<255>,
5230                            D,
5231                            val,
5232                            decoder,
5233                            _inner_offset,
5234                            depth
5235                        )?;
5236                    } else {
5237                        unreachable!()
5238                    }
5239                }
5240                63 => {
5241                    #[allow(irrefutable_let_patterns)]
5242                    if let Option_::BootfileName(_) = self {
5243                        // Do nothing, read the value into the object
5244                    } else {
5245                        // Initialize `self` to the right variant
5246                        *self = Option_::BootfileName(fidl::new_empty!(
5247                            fidl::encoding::BoundedString<255>,
5248                            D
5249                        ));
5250                    }
5251                    #[allow(irrefutable_let_patterns)]
5252                    if let Option_::BootfileName(ref mut val) = self {
5253                        fidl::decode!(
5254                            fidl::encoding::BoundedString<255>,
5255                            D,
5256                            val,
5257                            decoder,
5258                            _inner_offset,
5259                            depth
5260                        )?;
5261                    } else {
5262                        unreachable!()
5263                    }
5264                }
5265                64 => {
5266                    #[allow(irrefutable_let_patterns)]
5267                    if let Option_::MaxDhcpMessageSize(_) = self {
5268                        // Do nothing, read the value into the object
5269                    } else {
5270                        // Initialize `self` to the right variant
5271                        *self = Option_::MaxDhcpMessageSize(fidl::new_empty!(u16, D));
5272                    }
5273                    #[allow(irrefutable_let_patterns)]
5274                    if let Option_::MaxDhcpMessageSize(ref mut val) = self {
5275                        fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
5276                    } else {
5277                        unreachable!()
5278                    }
5279                }
5280                65 => {
5281                    #[allow(irrefutable_let_patterns)]
5282                    if let Option_::RenewalTimeValue(_) = self {
5283                        // Do nothing, read the value into the object
5284                    } else {
5285                        // Initialize `self` to the right variant
5286                        *self = Option_::RenewalTimeValue(fidl::new_empty!(u32, D));
5287                    }
5288                    #[allow(irrefutable_let_patterns)]
5289                    if let Option_::RenewalTimeValue(ref mut val) = self {
5290                        fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
5291                    } else {
5292                        unreachable!()
5293                    }
5294                }
5295                66 => {
5296                    #[allow(irrefutable_let_patterns)]
5297                    if let Option_::RebindingTimeValue(_) = self {
5298                        // Do nothing, read the value into the object
5299                    } else {
5300                        // Initialize `self` to the right variant
5301                        *self = Option_::RebindingTimeValue(fidl::new_empty!(u32, D));
5302                    }
5303                    #[allow(irrefutable_let_patterns)]
5304                    if let Option_::RebindingTimeValue(ref mut val) = self {
5305                        fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
5306                    } else {
5307                        unreachable!()
5308                    }
5309                }
5310                #[allow(deprecated)]
5311                ordinal => {
5312                    for _ in 0..num_handles {
5313                        decoder.drop_next_handle()?;
5314                    }
5315                    *self = Option_::__SourceBreaking { unknown_ordinal: ordinal };
5316                }
5317            }
5318            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
5319                return Err(fidl::Error::InvalidNumBytesInEnvelope);
5320            }
5321            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5322                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5323            }
5324            Ok(())
5325        }
5326    }
5327
5328    impl fidl::encoding::ValueTypeMarker for Parameter {
5329        type Borrowed<'a> = &'a Self;
5330        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
5331            value
5332        }
5333    }
5334
5335    unsafe impl fidl::encoding::TypeMarker for Parameter {
5336        type Owned = Self;
5337
5338        #[inline(always)]
5339        fn inline_align(_context: fidl::encoding::Context) -> usize {
5340            8
5341        }
5342
5343        #[inline(always)]
5344        fn inline_size(_context: fidl::encoding::Context) -> usize {
5345            16
5346        }
5347    }
5348
5349    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Parameter, D>
5350        for &Parameter
5351    {
5352        #[inline]
5353        unsafe fn encode(
5354            self,
5355            encoder: &mut fidl::encoding::Encoder<'_, D>,
5356            offset: usize,
5357            _depth: fidl::encoding::Depth,
5358        ) -> fidl::Result<()> {
5359            encoder.debug_check_bounds::<Parameter>(offset);
5360            encoder.write_num::<u64>(self.ordinal(), offset);
5361            match self {
5362            Parameter::IpAddrs(ref val) => {
5363                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 256>, D>(
5364                    <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 256> as fidl::encoding::ValueTypeMarker>::borrow(val),
5365                    encoder, offset + 8, _depth
5366                )
5367            }
5368            Parameter::AddressPool(ref val) => {
5369                fidl::encoding::encode_in_envelope::<AddressPool, D>(
5370                    <AddressPool as fidl::encoding::ValueTypeMarker>::borrow(val),
5371                    encoder, offset + 8, _depth
5372                )
5373            }
5374            Parameter::Lease(ref val) => {
5375                fidl::encoding::encode_in_envelope::<LeaseLength, D>(
5376                    <LeaseLength as fidl::encoding::ValueTypeMarker>::borrow(val),
5377                    encoder, offset + 8, _depth
5378                )
5379            }
5380            Parameter::PermittedMacs(ref val) => {
5381                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 256>, D>(
5382                    <fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 256> as fidl::encoding::ValueTypeMarker>::borrow(val),
5383                    encoder, offset + 8, _depth
5384                )
5385            }
5386            Parameter::StaticallyAssignedAddrs(ref val) => {
5387                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<StaticAssignment, 256>, D>(
5388                    <fidl::encoding::Vector<StaticAssignment, 256> as fidl::encoding::ValueTypeMarker>::borrow(val),
5389                    encoder, offset + 8, _depth
5390                )
5391            }
5392            Parameter::ArpProbe(ref val) => {
5393                fidl::encoding::encode_in_envelope::<bool, D>(
5394                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
5395                    encoder, offset + 8, _depth
5396                )
5397            }
5398            Parameter::BoundDeviceNames(ref val) => {
5399                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 256>, D>(
5400                    <fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 256> as fidl::encoding::ValueTypeMarker>::borrow(val),
5401                    encoder, offset + 8, _depth
5402                )
5403            }
5404            Parameter::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
5405        }
5406        }
5407    }
5408
5409    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Parameter {
5410        #[inline(always)]
5411        fn new_empty() -> Self {
5412            Self::__SourceBreaking { unknown_ordinal: 0 }
5413        }
5414
5415        #[inline]
5416        unsafe fn decode(
5417            &mut self,
5418            decoder: &mut fidl::encoding::Decoder<'_, D>,
5419            offset: usize,
5420            mut depth: fidl::encoding::Depth,
5421        ) -> fidl::Result<()> {
5422            decoder.debug_check_bounds::<Self>(offset);
5423            #[allow(unused_variables)]
5424            let next_out_of_line = decoder.next_out_of_line();
5425            let handles_before = decoder.remaining_handles();
5426            let (ordinal, inlined, num_bytes, num_handles) =
5427                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
5428
5429            let member_inline_size = match ordinal {
5430            1 => <fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 256> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5431            2 => <AddressPool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5432            3 => <LeaseLength as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5433            4 => <fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 256> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5434            5 => <fidl::encoding::Vector<StaticAssignment, 256> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5435            6 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5436            7 => <fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 256> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
5437            0 => return Err(fidl::Error::UnknownUnionTag),
5438            _ => num_bytes as usize,
5439        };
5440
5441            if inlined != (member_inline_size <= 4) {
5442                return Err(fidl::Error::InvalidInlineBitInEnvelope);
5443            }
5444            let _inner_offset;
5445            if inlined {
5446                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
5447                _inner_offset = offset + 8;
5448            } else {
5449                depth.increment()?;
5450                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5451            }
5452            match ordinal {
5453                1 => {
5454                    #[allow(irrefutable_let_patterns)]
5455                    if let Parameter::IpAddrs(_) = self {
5456                        // Do nothing, read the value into the object
5457                    } else {
5458                        // Initialize `self` to the right variant
5459                        *self = Parameter::IpAddrs(
5460                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 256>, D),
5461                        );
5462                    }
5463                    #[allow(irrefutable_let_patterns)]
5464                    if let Parameter::IpAddrs(ref mut val) = self {
5465                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::Ipv4Address, 256>, D, val, decoder, _inner_offset, depth)?;
5466                    } else {
5467                        unreachable!()
5468                    }
5469                }
5470                2 => {
5471                    #[allow(irrefutable_let_patterns)]
5472                    if let Parameter::AddressPool(_) = self {
5473                        // Do nothing, read the value into the object
5474                    } else {
5475                        // Initialize `self` to the right variant
5476                        *self = Parameter::AddressPool(fidl::new_empty!(AddressPool, D));
5477                    }
5478                    #[allow(irrefutable_let_patterns)]
5479                    if let Parameter::AddressPool(ref mut val) = self {
5480                        fidl::decode!(AddressPool, D, val, decoder, _inner_offset, depth)?;
5481                    } else {
5482                        unreachable!()
5483                    }
5484                }
5485                3 => {
5486                    #[allow(irrefutable_let_patterns)]
5487                    if let Parameter::Lease(_) = self {
5488                        // Do nothing, read the value into the object
5489                    } else {
5490                        // Initialize `self` to the right variant
5491                        *self = Parameter::Lease(fidl::new_empty!(LeaseLength, D));
5492                    }
5493                    #[allow(irrefutable_let_patterns)]
5494                    if let Parameter::Lease(ref mut val) = self {
5495                        fidl::decode!(LeaseLength, D, val, decoder, _inner_offset, depth)?;
5496                    } else {
5497                        unreachable!()
5498                    }
5499                }
5500                4 => {
5501                    #[allow(irrefutable_let_patterns)]
5502                    if let Parameter::PermittedMacs(_) = self {
5503                        // Do nothing, read the value into the object
5504                    } else {
5505                        // Initialize `self` to the right variant
5506                        *self = Parameter::PermittedMacs(
5507                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 256>, D),
5508                        );
5509                    }
5510                    #[allow(irrefutable_let_patterns)]
5511                    if let Parameter::PermittedMacs(ref mut val) = self {
5512                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net__common::MacAddress, 256>, D, val, decoder, _inner_offset, depth)?;
5513                    } else {
5514                        unreachable!()
5515                    }
5516                }
5517                5 => {
5518                    #[allow(irrefutable_let_patterns)]
5519                    if let Parameter::StaticallyAssignedAddrs(_) = self {
5520                        // Do nothing, read the value into the object
5521                    } else {
5522                        // Initialize `self` to the right variant
5523                        *self = Parameter::StaticallyAssignedAddrs(
5524                            fidl::new_empty!(fidl::encoding::Vector<StaticAssignment, 256>, D),
5525                        );
5526                    }
5527                    #[allow(irrefutable_let_patterns)]
5528                    if let Parameter::StaticallyAssignedAddrs(ref mut val) = self {
5529                        fidl::decode!(fidl::encoding::Vector<StaticAssignment, 256>, D, val, decoder, _inner_offset, depth)?;
5530                    } else {
5531                        unreachable!()
5532                    }
5533                }
5534                6 => {
5535                    #[allow(irrefutable_let_patterns)]
5536                    if let Parameter::ArpProbe(_) = self {
5537                        // Do nothing, read the value into the object
5538                    } else {
5539                        // Initialize `self` to the right variant
5540                        *self = Parameter::ArpProbe(fidl::new_empty!(bool, D));
5541                    }
5542                    #[allow(irrefutable_let_patterns)]
5543                    if let Parameter::ArpProbe(ref mut val) = self {
5544                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
5545                    } else {
5546                        unreachable!()
5547                    }
5548                }
5549                7 => {
5550                    #[allow(irrefutable_let_patterns)]
5551                    if let Parameter::BoundDeviceNames(_) = self {
5552                        // Do nothing, read the value into the object
5553                    } else {
5554                        // Initialize `self` to the right variant
5555                        *self = Parameter::BoundDeviceNames(fidl::new_empty!(
5556                            fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 256>,
5557                            D
5558                        ));
5559                    }
5560                    #[allow(irrefutable_let_patterns)]
5561                    if let Parameter::BoundDeviceNames(ref mut val) = self {
5562                        fidl::decode!(
5563                            fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 256>,
5564                            D,
5565                            val,
5566                            decoder,
5567                            _inner_offset,
5568                            depth
5569                        )?;
5570                    } else {
5571                        unreachable!()
5572                    }
5573                }
5574                #[allow(deprecated)]
5575                ordinal => {
5576                    for _ in 0..num_handles {
5577                        decoder.drop_next_handle()?;
5578                    }
5579                    *self = Parameter::__SourceBreaking { unknown_ordinal: ordinal };
5580                }
5581            }
5582            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
5583                return Err(fidl::Error::InvalidNumBytesInEnvelope);
5584            }
5585            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5586                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5587            }
5588            Ok(())
5589        }
5590    }
5591}