fidl_fuchsia_net_dhcp_common/

fidl_fuchsia_net_dhcp_common.rs

// WARNING: This file is machine generated by fidlgen.

#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]

use bitflags::bitflags;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

/// A DHCP option field of IP addresses.
///
/// Per https://tools.ietf.org/html/rfc2132#section-2:
///
///   All other options are variable-length with a length octet following the tag octet.
///
/// The maximum length is given by 0xFF/sizeof([`fuchsia.net.Ipv4Address`]).
pub type Addresses = Vec<fidl_fuchsia_net::Ipv4Address>;

/// A DHCP option field of ASCII characters.
///
/// Per https://tools.ietf.org/html/rfc2132#section-2:
///
///   All other options are variable-length with a length octet following the tag octet.
///
/// Valid iff it consists of characters from the ASCII character set.
pub type AsciiString = String;

/// A DHCP duration value, in seconds. As specified in
/// https://tools.ietf.org/html/rfc2131#section-3.3, DHCP duration values are
/// relative times.
pub type Duration = u32;

/// The maximum possible number of DNS servers that can be included in an
/// acquired DHCP configuration.
///
/// According to [RFC 2132 section
/// 3.8](https://www.rfc-editor.org/rfc/rfc2132#section-3.8), the length of the
/// DNS server list in bytes is represented in the protocol by an 8-bit unsigned
/// integer:
/// "[variable-length options have] a length octet following the tag octet. The
/// value of the length octet does not include the two octets specifying the tag
/// and length."
/// 2^8 = 256, which divided by 4 bytes gives us 64 as an upper bound on the
/// maximum possible number of DNS servers that can be included in an acquired
/// DHCP configuration.
pub const MAX_DNS_SERVERS: u8 = 64;

/// The maximum possible number of routers that can be included in an acquired
/// DHCP configuration.
///
/// According to [RFC 2132 section
/// 3.5](https://www.rfc-editor.org/rfc/rfc2132#section-3.5), the length of the
/// routers list in bytes is represented in the protocol by an 8-bit unsigned
/// integer:
/// "[variable-length options have] a length octet following the tag octet. The
/// value of the length octet does not include the two octets specifying the
/// tag and length."
/// 2^8 = 256, which divided by 4 bytes gives us 64 as an upper bound on the
/// maximum possible number of routers that can be included in an acquired
/// DHCP configuration.
pub const MAX_ROUTERS: u8 = 64;

bitflags! {
    /// A NetBIOS over TCP/IP node type as defined in RFC 1001/1002. This bitflag is for use with the
    /// NetBiosOverTcpipNodeType option.
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct NodeTypes: u8 {
        /// A B node type.
        const B_NODE = 1;
        /// A P node type.
        const P_NODE = 2;
        /// A M node type.
        const M_NODE = 4;
        /// A H node type.
        const H_NODE = 8;
    }
}

impl NodeTypes {
    #[deprecated = "Strict bits should not use `has_unknown_bits`"]
    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        false
    }

    #[deprecated = "Strict bits should not use `get_unknown_bits`"]
    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u8 {
        0
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum ClientExitReason {
    /// A client already exists on the interface.
    ClientAlreadyExistsOnInterface = 1,
    /// More than one concurrent call to `WatchConfiguration` was made.
    WatchConfigurationAlreadyPending = 2,
    /// The interface identified is invalid for acquiring configuration.
    InvalidInterface = 3,
    /// Invalid `NewClientParams` were provided.
    InvalidParams = 4,
    /// The network was, or became, unreachable over the interface
    /// provided to the DHCP client.
    NetworkUnreachable = 5,
    /// The client was unable to open a socket.
    UnableToOpenSocket = 6,
    /// Graceful shutdown was performed.
    GracefulShutdown = 7,
    /// An address acquired by this client was removed by a user.
    AddressRemovedByUser = 8,
    /// The `AddressStateProvider` for an address acquired by this
    /// client exited with an error (or without providing a reason for
    /// the address removal).
    AddressStateProviderError = 9,
}

impl ClientExitReason {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::ClientAlreadyExistsOnInterface),
            2 => Some(Self::WatchConfigurationAlreadyPending),
            3 => Some(Self::InvalidInterface),
            4 => Some(Self::InvalidParams),
            5 => Some(Self::NetworkUnreachable),
            6 => Some(Self::UnableToOpenSocket),
            7 => Some(Self::GracefulShutdown),
            8 => Some(Self::AddressRemovedByUser),
            9 => Some(Self::AddressStateProviderError),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// The type of DHCP message. The DHCP protocol requires that all messages identify
/// their type by including the MessageType option. These values are specified
/// in https://tools.ietf.org/html/rfc2132#section-9.6.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u8)]
pub enum MessageType {
    /// A DHCP Discover message.
    Dhcpdiscover = 1,
    /// A DHCP Offer message.
    Dhcpoffer = 2,
    /// A DHCP Request message.
    Dhcprequest = 3,
    /// A DHCP Decline message.
    Dhcpdecline = 4,
    /// A DHCP Ack message.
    Dhcpack = 5,
    /// A DHCP Nak message;
    Dhcpnak = 6,
    /// A DHCP Release message;
    Dhcprelease = 7,
    /// A DHCP Inform message.
    Dhcpinform = 8,
}

impl MessageType {
    #[inline]
    pub fn from_primitive(prim: u8) -> Option<Self> {
        match prim {
            1 => Some(Self::Dhcpdiscover),
            2 => Some(Self::Dhcpoffer),
            3 => Some(Self::Dhcprequest),
            4 => Some(Self::Dhcpdecline),
            5 => Some(Self::Dhcpack),
            6 => Some(Self::Dhcpnak),
            7 => Some(Self::Dhcprelease),
            8 => Some(Self::Dhcpinform),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u8 {
        self as u8
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// The code of a DHCP option to be retrieved by Server.GetOption(). The code
/// values are from https://tools.ietf.org/html/rfc2132 and the enum variants
/// have been listed in the order they are presented in the RFC.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum OptionCode {
    SubnetMask = 1,
    TimeOffset = 2,
    Router = 3,
    TimeServer = 4,
    NameServer = 5,
    DomainNameServer = 6,
    LogServer = 7,
    CookieServer = 8,
    LprServer = 9,
    ImpressServer = 10,
    ResourceLocationServer = 11,
    HostName = 12,
    BootFileSize = 13,
    MeritDumpFile = 14,
    DomainName = 15,
    SwapServer = 16,
    RootPath = 17,
    ExtensionsPath = 18,
    IpForwarding = 19,
    NonLocalSourceRouting = 20,
    PolicyFilter = 21,
    MaxDatagramReassemblySize = 22,
    DefaultIpTtl = 23,
    PathMtuAgingTimeout = 24,
    PathMtuPlateauTable = 25,
    InterfaceMtu = 26,
    AllSubnetsLocal = 27,
    BroadcastAddress = 28,
    PerformMaskDiscovery = 29,
    MaskSupplier = 30,
    PerformRouterDiscovery = 31,
    RouterSolicitationAddress = 32,
    StaticRoute = 33,
    TrailerEncapsulation = 34,
    ArpCacheTimeout = 35,
    EthernetEncapsulation = 36,
    TcpDefaultTtl = 37,
    TcpKeepaliveInterval = 38,
    TcpKeepaliveGarbage = 39,
    NetworkInformationServiceDomain = 40,
    NetworkInformationServers = 41,
    NetworkTimeProtocolServers = 42,
    VendorSpecificInformation = 43,
    NetbiosOverTcpipNameServer = 44,
    NetbiosOverTcpipDatagramDistributionServer = 45,
    NetbiosOverTcpipNodeType = 46,
    NetbiosOverTcpipScope = 47,
    XWindowSystemFontServer = 48,
    XWindowSystemDisplayManager = 49,
    NetworkInformationServicePlusDomain = 64,
    NetworkInformationServicePlusServers = 65,
    MobileIpHomeAgent = 68,
    SmtpServer = 69,
    Pop3Server = 70,
    NntpServer = 71,
    DefaultWwwServer = 72,
    DefaultFingerServer = 73,
    DefaultIrcServer = 74,
    StreettalkServer = 75,
    StreettalkDirectoryAssistanceServer = 76,
    OptionOverload = 52,
    TftpServerName = 66,
    BootfileName = 67,
    MaxDhcpMessageSize = 57,
    RenewalTimeValue = 58,
    RebindingTimeValue = 59,
}

impl OptionCode {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            1 => Some(Self::SubnetMask),
            2 => Some(Self::TimeOffset),
            3 => Some(Self::Router),
            4 => Some(Self::TimeServer),
            5 => Some(Self::NameServer),
            6 => Some(Self::DomainNameServer),
            7 => Some(Self::LogServer),
            8 => Some(Self::CookieServer),
            9 => Some(Self::LprServer),
            10 => Some(Self::ImpressServer),
            11 => Some(Self::ResourceLocationServer),
            12 => Some(Self::HostName),
            13 => Some(Self::BootFileSize),
            14 => Some(Self::MeritDumpFile),
            15 => Some(Self::DomainName),
            16 => Some(Self::SwapServer),
            17 => Some(Self::RootPath),
            18 => Some(Self::ExtensionsPath),
            19 => Some(Self::IpForwarding),
            20 => Some(Self::NonLocalSourceRouting),
            21 => Some(Self::PolicyFilter),
            22 => Some(Self::MaxDatagramReassemblySize),
            23 => Some(Self::DefaultIpTtl),
            24 => Some(Self::PathMtuAgingTimeout),
            25 => Some(Self::PathMtuPlateauTable),
            26 => Some(Self::InterfaceMtu),
            27 => Some(Self::AllSubnetsLocal),
            28 => Some(Self::BroadcastAddress),
            29 => Some(Self::PerformMaskDiscovery),
            30 => Some(Self::MaskSupplier),
            31 => Some(Self::PerformRouterDiscovery),
            32 => Some(Self::RouterSolicitationAddress),
            33 => Some(Self::StaticRoute),
            34 => Some(Self::TrailerEncapsulation),
            35 => Some(Self::ArpCacheTimeout),
            36 => Some(Self::EthernetEncapsulation),
            37 => Some(Self::TcpDefaultTtl),
            38 => Some(Self::TcpKeepaliveInterval),
            39 => Some(Self::TcpKeepaliveGarbage),
            40 => Some(Self::NetworkInformationServiceDomain),
            41 => Some(Self::NetworkInformationServers),
            42 => Some(Self::NetworkTimeProtocolServers),
            43 => Some(Self::VendorSpecificInformation),
            44 => Some(Self::NetbiosOverTcpipNameServer),
            45 => Some(Self::NetbiosOverTcpipDatagramDistributionServer),
            46 => Some(Self::NetbiosOverTcpipNodeType),
            47 => Some(Self::NetbiosOverTcpipScope),
            48 => Some(Self::XWindowSystemFontServer),
            49 => Some(Self::XWindowSystemDisplayManager),
            64 => Some(Self::NetworkInformationServicePlusDomain),
            65 => Some(Self::NetworkInformationServicePlusServers),
            68 => Some(Self::MobileIpHomeAgent),
            69 => Some(Self::SmtpServer),
            70 => Some(Self::Pop3Server),
            71 => Some(Self::NntpServer),
            72 => Some(Self::DefaultWwwServer),
            73 => Some(Self::DefaultFingerServer),
            74 => Some(Self::DefaultIrcServer),
            75 => Some(Self::StreettalkServer),
            76 => Some(Self::StreettalkDirectoryAssistanceServer),
            52 => Some(Self::OptionOverload),
            66 => Some(Self::TftpServerName),
            67 => Some(Self::BootfileName),
            57 => Some(Self::MaxDhcpMessageSize),
            58 => Some(Self::RenewalTimeValue),
            59 => Some(Self::RebindingTimeValue),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// A indication of which DHCP message field should be used to store additional options.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u8)]
pub enum OptionOverloadValue {
    /// The file DHCP field.
    File = 1,
    /// The sname DHCP field.
    Sname = 2,
    /// Both file and sname DHCP fields.
    Both = 3,
}

impl OptionOverloadValue {
    #[inline]
    pub fn from_primitive(prim: u8) -> Option<Self> {
        match prim {
            1 => Some(Self::File),
            2 => Some(Self::Sname),
            3 => Some(Self::Both),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u8 {
        self as u8
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// The name of the Parameter to be retrieved by Server.GetParameter().
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum ParameterName {
    IpAddrs = 0,
    AddressPool = 1,
    LeaseLength = 2,
    PermittedMacs = 3,
    StaticallyAssignedAddrs = 4,
    ArpProbe = 5,
    BoundDeviceNames = 6,
}

impl ParameterName {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::IpAddrs),
            1 => Some(Self::AddressPool),
            2 => Some(Self::LeaseLength),
            3 => Some(Self::PermittedMacs),
            4 => Some(Self::StaticallyAssignedAddrs),
            5 => Some(Self::ArpProbe),
            6 => Some(Self::BoundDeviceNames),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ClientOnExitRequest {
    pub reason: ClientExitReason,
}

impl fidl::Persistable for ClientOnExitRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ServerGetOptionRequest {
    pub code: OptionCode,
}

impl fidl::Persistable for ServerGetOptionRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ServerGetParameterRequest {
    pub name: ParameterName,
}

impl fidl::Persistable for ServerGetParameterRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ServerIsServingResponse {
    pub enabled: bool,
}

impl fidl::Persistable for ServerIsServingResponse {}

#[derive(Clone, Debug, PartialEq)]
pub struct ServerSetOptionRequest {
    pub value: Option_,
}

impl fidl::Persistable for ServerSetOptionRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct ServerSetParameterRequest {
    pub value: Parameter,
}

impl fidl::Persistable for ServerSetParameterRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct ServerGetOptionResponse {
    pub value: Option_,
}

impl fidl::Persistable for ServerGetOptionResponse {}

#[derive(Clone, Debug, PartialEq)]
pub struct ServerGetParameterResponse {
    pub value: Parameter,
}

impl fidl::Persistable for ServerGetParameterResponse {}

#[derive(Clone, Debug, PartialEq)]
pub struct ServerListOptionsResponse {
    pub options: Vec<Option_>,
}

impl fidl::Persistable for ServerListOptionsResponse {}

#[derive(Clone, Debug, PartialEq)]
pub struct ServerListParametersResponse {
    pub parameters: Vec<Parameter>,
}

impl fidl::Persistable for ServerListParametersResponse {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct AddressPool {
    /// The prefix length (in bits) of the address pool's subnet mask.
    pub prefix_length: Option<u8>,
    /// The starting address, inclusive, of the range of addresses which the
    /// DHCP server will lease to clients.
    pub range_start: Option<fidl_fuchsia_net::Ipv4Address>,
    /// The ending address, exclusive, of the range of addresses which the
    /// server will lease to clients.
    pub range_stop: Option<fidl_fuchsia_net::Ipv4Address>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for AddressPool {}

/// Describes the configuration information the DHCP client requests from DHCP
/// servers.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ConfigurationToRequest {
    /// Request a list of IP addresses for routers on the client's subnet,
    /// in order of preference.
    /// See [RFC 2132 section 3.5](https://www.rfc-editor.org/rfc/rfc2132#section-3.5).
    ///
    /// If not set, interpreted as false.
    pub routers: Option<bool>,
    /// Request a list of available DNS servers.
    /// See [RFC 2132 section 3.8](https://www.rfc-editor.org/rfc/rfc2132#section-3.8).
    ///
    /// If not set, interpreted as false.
    pub dns_servers: Option<bool>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for ConfigurationToRequest {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct LeaseLength {
    /// The default lease length to be issued to clients. This field must
    /// have a value.
    pub default: Option<u32>,
    /// The maximum lease length value which the server will issue to
    /// clients who have requested a specific lease length. If omitted, the
    /// max lease length is equivalent to the default lease length.
    pub max: Option<u32>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for LeaseLength {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct NewClientParams {
    /// Parameters for describing the configuration information the DHCP
    /// client requests from DHCP servers.
    ///
    /// If not set, interpreted as empty (no configuration information
    /// is requested).
    pub configuration_to_request: Option<ConfigurationToRequest>,
    /// Whether the client negotiates an IP address.
    ///
    /// If false or not set, the client asks only for local
    /// configuration parameters.
    /// See [RFC 2131 section 3.4](https://www.rfc-editor.org/rfc/rfc2131#section-3.4).
    pub request_ip_address: Option<bool>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for NewClientParams {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct StaticAssignment {
    /// The MAC address of the host or device which will have the static IP
    /// address assignment.
    pub host: Option<fidl_fuchsia_net::MacAddress>,
    /// The IP address which the host or device will always be assigned the
    /// server.
    pub assigned_addr: Option<fidl_fuchsia_net::Ipv4Address>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for StaticAssignment {}

/// A generic representation of client configuration parameters and DHCP settings. Options are the
/// mechanism by which the DHCP protocol communicates configuration parameters from a repository on
/// a DHCP server to DHCP clients, or by which DHCP clients and servers communicate data relevant to
/// a DHCP transaction.
/// All DHCP option values must have a length which can fit within a single byte, i.e. less than 256.
/// Options for which there is no reasonable administrator-configurable value have been omitted
/// from this xunion. The omitted options are:
/// * Pad - never has a value
/// * End - never has a value
/// * RequestedIpAddress - value always selected by the DHCP client.
/// * DhcpMessageType - value always determined by state of transaction between DHCP client and server.
/// * ServerIdentifier - value always determined by address to which the server is bound.
/// * ParameterRequestList - value always selected by the DHCP client.
/// * Message - value determined in response to runtime error.
/// * VendorClassIdentifer - value always selected by the DHCP client.
/// * ClientIdentifier - value always selected by the DHCP client.
#[derive(Clone, Debug)]
pub enum Option_ {
    /// A 32-bit IPv4 subnet mask.
    SubnetMask(fidl_fuchsia_net::Ipv4Address),
    /// The client's offset from UTC in seconds. A positive offset is east of the zero meridian, and
    /// a negative offset is west of the zero meridian.
    TimeOffset(i32),
    /// A list of the routers in a client's subnet, listed in order of preference.
    Router(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of time servers available to the client, in order of preference.
    TimeServer(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of IEN 116 Name servers available to the client, in order of preference.
    NameServer(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of Domain Name System servers available to the client, in order of preference;
    DomainNameServer(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of MIT-LCS UDP Log servers available to the client, in order of preference.
    LogServer(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of RFC 865 Cookie servers available to the client, in order of preference.
    CookieServer(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of RFC 1179 Line Printer servers available to the client, in order of preference.
    LprServer(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of Imagen Impress servers available to the client, in order of preference.
    ImpressServer(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of RFC 887 Resource Location servers available to the client, in order of preference.
    ResourceLocationServer(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// The host name of the client, which may or may not be qualified with the local domain name.
    HostName(String),
    /// The size of the client's default boot image in 512-octet blocks.
    BootFileSize(u16),
    /// The path name to the client's core dump in the event the client crashes.
    MeritDumpFile(String),
    /// The client's domain name for use in resolving hostnames in the DNS.
    DomainName(String),
    /// The address of the client's swap server.
    SwapServer(fidl_fuchsia_net::Ipv4Address),
    /// The path name to the client's root disk.
    RootPath(String),
    /// The path name to a TFTP-retrievable file. This file contains data which can be interpreted
    /// as the BOOTP vendor-extension field. Unlike the BOOTP vendor-extension field, this file has
    /// an unconstrained length and any references to Tag 18 are ignored.
    ExtensionsPath(String),
    /// A flag which will enabled IP layer packet forwarding when true.
    IpForwarding(bool),
    /// A flag which will enable forwarding of IP packets with non-local source routes.
    NonLocalSourceRouting(bool),
    /// Policy filters for non-local source routing.
    /// A list of IP Address and Subnet Mask pairs. If an incoming source-routed packet has a
    /// next-hop that does not match one of these pairs, then the packet will be dropped.
    PolicyFilter(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// The maximum sized datagram that the client should be able to reassemble, in octets. The
    /// minimum legal value is 576.
    MaxDatagramReassemblySize(u16),
    /// The default time-to-live to use on outgoing IP datagrams. The value must be between 1 and
    /// 255.
    DefaultIpTtl(u8),
    /// The timeout to be used when aging Path MTU values by the mechanism in RFC 1191.
    PathMtuAgingTimeout(u32),
    /// Table of MTU sizes for Path MTU Discovery.
    /// A list of MTU sizes, ordered from smallest to largest. The smallest value cannot be smaller
    /// than 68.
    PathMtuPlateauTable(Vec<u16>),
    /// The MTU for the client's interface. Minimum value of 68.
    InterfaceMtu(u16),
    /// A flag indicating if all subents of the IP network to which the client is connected have the
    /// same MTU.
    AllSubnetsLocal(bool),
    /// The broadcast address of the client's subnet. Legal values are defined in RFC 1122.
    BroadcastAddress(fidl_fuchsia_net::Ipv4Address),
    /// A flag indicating whether the client should perform subnet mask discovery via ICMP.
    PerformMaskDiscovery(bool),
    /// A flag indicating whether the client should respond to subnet mask discovery requests via
    /// ICMP.
    MaskSupplier(bool),
    /// A flag indicating whether the client should solicit routers using Router Discovery as
    /// defined in RFC 1256.
    PerformRouterDiscovery(bool),
    /// The address to which the client should transmit Router Solicitation requests.
    RouterSolicitationAddress(fidl_fuchsia_net::Ipv4Address),
    /// Static Routes which the host should put in its routing cache.
    /// A list of Destination address/Next-hop address pairs defining static routes for the client's
    /// routing table. The routes should be listed in descending order of priority. It is illegal
    /// to use 0.0.0.0 as the destination in a static route.
    StaticRoute(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A flag specifying whether the client negotiate the use of trailers when using ARP, per RFC
    /// 893.
    TrailerEncapsulation(bool),
    /// The timeout for ARP cache entries.
    ArpCacheTimeout(u32),
    /// A flag specifying that the client should use Ethernet v2 encapsulation when false, and IEEE
    /// 802.3 encapsulation when true.
    EthernetEncapsulation(bool),
    /// The default time-to-live that the client should use for outgoing TCP segments. The minimum
    /// value is 1.
    TcpDefaultTtl(u8),
    /// The interval the client should wait before sending a TCP keepalive message. A
    /// value of 0 indicates that the client should not send keepalive messages unless specifically
    /// requested by an application.
    TcpKeepaliveInterval(u32),
    /// A flag specifying whether the client should send TCP keepalive messages with an octet of
    /// garbage for compatibility with older implementations.
    TcpKeepaliveGarbage(bool),
    /// The name of the client's Network Information Service domain.
    NetworkInformationServiceDomain(String),
    /// A list of Network Information Service server addresses available to the client, listed in
    /// order of preference.
    NetworkInformationServers(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of Network Time Protocol (NTP) server addresses available to the client, listed in
    /// order of preference.
    NetworkTimeProtocolServers(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// An opaque object of octets for exchanging vendor-specific information.
    VendorSpecificInformation(Vec<u8>),
    /// A list of NetBIOS name server addresses available to the client, listed in order of
    /// preference.
    NetbiosOverTcpipNameServer(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of NetBIOS datagram distribution servers available to the client, listed in order of
    /// preference.
    NetbiosOverTcpipDatagramDistributionServer(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// The NetBIOS node type which should be used by the client.
    NetbiosOverTcpipNodeType(NodeTypes),
    /// The NetBIOS over TCP/IP scope parameter, as defined in RFC 1001, for the client.
    NetbiosOverTcpipScope(String),
    /// A list of X Window System Font server addresses available to the client, listed in order of
    /// preference.
    XWindowSystemFontServer(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of X Window System Display Manager system addresses available to the client, listed
    /// in order of preference.
    XWindowSystemDisplayManager(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// The name of the client's Network Information System+ domain.
    NetworkInformationServicePlusDomain(String),
    /// A list of Network Information System+ server addresses available to the client, listed in
    /// order of preference.
    NetworkInformationServicePlusServers(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of mobile IP home agent addresses available to the client, listed in order of
    /// preference.
    MobileIpHomeAgent(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of Simple Mail Transport Protocol (SMTP) server address available to the client,
    /// listed in order of preference.
    SmtpServer(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of Post Office Protocol (POP3) server addresses available to the client, listed in
    /// order of preference.
    Pop3Server(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list Network News Transport Protocol (NNTP) server addresses available to the client,
    /// listed in order of preference.
    NntpServer(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of default World Wide Web (WWW) server addresses available to the client, listed in
    /// order of preference.
    DefaultWwwServer(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of default Finger server addresses available to the client, listed in order of
    /// preference.
    DefaultFingerServer(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of Internet Relay Chat server addresses available to the client, listed in order of
    /// preference.
    DefaultIrcServer(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of StreetTalk server addresses available to the client, listed in order of
    /// preference.
    StreettalkServer(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// A list of StreetTalk Directory Assistance server addresses available to the client, listed
    /// in order of preference.
    StreettalkDirectoryAssistanceServer(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// An option specifying whether the `sname`, `file`, or both fields have been overloaded to
    /// carry DHCP options. If this option is present, the client interprets the additional fields
    /// after it concludes interpreting standard option fields.
    OptionOverload(OptionOverloadValue),
    /// The TFTP server name available to the client. This option should be used when the `sname`
    /// field has been overloaded to carry options.
    TftpServerName(String),
    /// The bootfile name for the client. This option should be used when the `file` field has been
    /// overloaded to carry options.
    BootfileName(String),
    /// The maximum length in octets of a DHCP message that the participant is willing to accept.
    /// The minimum value is 576.
    MaxDhcpMessageSize(u16),
    /// The time interval after address assignment at which the client will transition
    /// to the Renewing state.
    RenewalTimeValue(u32),
    /// The time interval after address assignment at which the client will transition
    /// to the Rebinding state.
    RebindingTimeValue(u32),
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u64 },
}

/// Pattern that matches an unknown `Option_` member.
#[macro_export]
macro_rules! Option_Unknown {
    () => {
        _
    };
}

// Custom PartialEq so that unknown variants are not equal to themselves.
impl PartialEq for Option_ {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::SubnetMask(x), Self::SubnetMask(y)) => *x == *y,
            (Self::TimeOffset(x), Self::TimeOffset(y)) => *x == *y,
            (Self::Router(x), Self::Router(y)) => *x == *y,
            (Self::TimeServer(x), Self::TimeServer(y)) => *x == *y,
            (Self::NameServer(x), Self::NameServer(y)) => *x == *y,
            (Self::DomainNameServer(x), Self::DomainNameServer(y)) => *x == *y,
            (Self::LogServer(x), Self::LogServer(y)) => *x == *y,
            (Self::CookieServer(x), Self::CookieServer(y)) => *x == *y,
            (Self::LprServer(x), Self::LprServer(y)) => *x == *y,
            (Self::ImpressServer(x), Self::ImpressServer(y)) => *x == *y,
            (Self::ResourceLocationServer(x), Self::ResourceLocationServer(y)) => *x == *y,
            (Self::HostName(x), Self::HostName(y)) => *x == *y,
            (Self::BootFileSize(x), Self::BootFileSize(y)) => *x == *y,
            (Self::MeritDumpFile(x), Self::MeritDumpFile(y)) => *x == *y,
            (Self::DomainName(x), Self::DomainName(y)) => *x == *y,
            (Self::SwapServer(x), Self::SwapServer(y)) => *x == *y,
            (Self::RootPath(x), Self::RootPath(y)) => *x == *y,
            (Self::ExtensionsPath(x), Self::ExtensionsPath(y)) => *x == *y,
            (Self::IpForwarding(x), Self::IpForwarding(y)) => *x == *y,
            (Self::NonLocalSourceRouting(x), Self::NonLocalSourceRouting(y)) => *x == *y,
            (Self::PolicyFilter(x), Self::PolicyFilter(y)) => *x == *y,
            (Self::MaxDatagramReassemblySize(x), Self::MaxDatagramReassemblySize(y)) => *x == *y,
            (Self::DefaultIpTtl(x), Self::DefaultIpTtl(y)) => *x == *y,
            (Self::PathMtuAgingTimeout(x), Self::PathMtuAgingTimeout(y)) => *x == *y,
            (Self::PathMtuPlateauTable(x), Self::PathMtuPlateauTable(y)) => *x == *y,
            (Self::InterfaceMtu(x), Self::InterfaceMtu(y)) => *x == *y,
            (Self::AllSubnetsLocal(x), Self::AllSubnetsLocal(y)) => *x == *y,
            (Self::BroadcastAddress(x), Self::BroadcastAddress(y)) => *x == *y,
            (Self::PerformMaskDiscovery(x), Self::PerformMaskDiscovery(y)) => *x == *y,
            (Self::MaskSupplier(x), Self::MaskSupplier(y)) => *x == *y,
            (Self::PerformRouterDiscovery(x), Self::PerformRouterDiscovery(y)) => *x == *y,
            (Self::RouterSolicitationAddress(x), Self::RouterSolicitationAddress(y)) => *x == *y,
            (Self::StaticRoute(x), Self::StaticRoute(y)) => *x == *y,
            (Self::TrailerEncapsulation(x), Self::TrailerEncapsulation(y)) => *x == *y,
            (Self::ArpCacheTimeout(x), Self::ArpCacheTimeout(y)) => *x == *y,
            (Self::EthernetEncapsulation(x), Self::EthernetEncapsulation(y)) => *x == *y,
            (Self::TcpDefaultTtl(x), Self::TcpDefaultTtl(y)) => *x == *y,
            (Self::TcpKeepaliveInterval(x), Self::TcpKeepaliveInterval(y)) => *x == *y,
            (Self::TcpKeepaliveGarbage(x), Self::TcpKeepaliveGarbage(y)) => *x == *y,
            (
                Self::NetworkInformationServiceDomain(x),
                Self::NetworkInformationServiceDomain(y),
            ) => *x == *y,
            (Self::NetworkInformationServers(x), Self::NetworkInformationServers(y)) => *x == *y,
            (Self::NetworkTimeProtocolServers(x), Self::NetworkTimeProtocolServers(y)) => *x == *y,
            (Self::VendorSpecificInformation(x), Self::VendorSpecificInformation(y)) => *x == *y,
            (Self::NetbiosOverTcpipNameServer(x), Self::NetbiosOverTcpipNameServer(y)) => *x == *y,
            (
                Self::NetbiosOverTcpipDatagramDistributionServer(x),
                Self::NetbiosOverTcpipDatagramDistributionServer(y),
            ) => *x == *y,
            (Self::NetbiosOverTcpipNodeType(x), Self::NetbiosOverTcpipNodeType(y)) => *x == *y,
            (Self::NetbiosOverTcpipScope(x), Self::NetbiosOverTcpipScope(y)) => *x == *y,
            (Self::XWindowSystemFontServer(x), Self::XWindowSystemFontServer(y)) => *x == *y,
            (Self::XWindowSystemDisplayManager(x), Self::XWindowSystemDisplayManager(y)) => {
                *x == *y
            }
            (
                Self::NetworkInformationServicePlusDomain(x),
                Self::NetworkInformationServicePlusDomain(y),
            ) => *x == *y,
            (
                Self::NetworkInformationServicePlusServers(x),
                Self::NetworkInformationServicePlusServers(y),
            ) => *x == *y,
            (Self::MobileIpHomeAgent(x), Self::MobileIpHomeAgent(y)) => *x == *y,
            (Self::SmtpServer(x), Self::SmtpServer(y)) => *x == *y,
            (Self::Pop3Server(x), Self::Pop3Server(y)) => *x == *y,
            (Self::NntpServer(x), Self::NntpServer(y)) => *x == *y,
            (Self::DefaultWwwServer(x), Self::DefaultWwwServer(y)) => *x == *y,
            (Self::DefaultFingerServer(x), Self::DefaultFingerServer(y)) => *x == *y,
            (Self::DefaultIrcServer(x), Self::DefaultIrcServer(y)) => *x == *y,
            (Self::StreettalkServer(x), Self::StreettalkServer(y)) => *x == *y,
            (
                Self::StreettalkDirectoryAssistanceServer(x),
                Self::StreettalkDirectoryAssistanceServer(y),
            ) => *x == *y,
            (Self::OptionOverload(x), Self::OptionOverload(y)) => *x == *y,
            (Self::TftpServerName(x), Self::TftpServerName(y)) => *x == *y,
            (Self::BootfileName(x), Self::BootfileName(y)) => *x == *y,
            (Self::MaxDhcpMessageSize(x), Self::MaxDhcpMessageSize(y)) => *x == *y,
            (Self::RenewalTimeValue(x), Self::RenewalTimeValue(y)) => *x == *y,
            (Self::RebindingTimeValue(x), Self::RebindingTimeValue(y)) => *x == *y,
            _ => false,
        }
    }
}

impl Option_ {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::SubnetMask(_) => 1,
            Self::TimeOffset(_) => 2,
            Self::Router(_) => 3,
            Self::TimeServer(_) => 4,
            Self::NameServer(_) => 5,
            Self::DomainNameServer(_) => 6,
            Self::LogServer(_) => 7,
            Self::CookieServer(_) => 8,
            Self::LprServer(_) => 9,
            Self::ImpressServer(_) => 10,
            Self::ResourceLocationServer(_) => 11,
            Self::HostName(_) => 12,
            Self::BootFileSize(_) => 13,
            Self::MeritDumpFile(_) => 14,
            Self::DomainName(_) => 15,
            Self::SwapServer(_) => 16,
            Self::RootPath(_) => 17,
            Self::ExtensionsPath(_) => 18,
            Self::IpForwarding(_) => 19,
            Self::NonLocalSourceRouting(_) => 20,
            Self::PolicyFilter(_) => 21,
            Self::MaxDatagramReassemblySize(_) => 22,
            Self::DefaultIpTtl(_) => 23,
            Self::PathMtuAgingTimeout(_) => 24,
            Self::PathMtuPlateauTable(_) => 25,
            Self::InterfaceMtu(_) => 26,
            Self::AllSubnetsLocal(_) => 27,
            Self::BroadcastAddress(_) => 28,
            Self::PerformMaskDiscovery(_) => 29,
            Self::MaskSupplier(_) => 30,
            Self::PerformRouterDiscovery(_) => 31,
            Self::RouterSolicitationAddress(_) => 32,
            Self::StaticRoute(_) => 33,
            Self::TrailerEncapsulation(_) => 34,
            Self::ArpCacheTimeout(_) => 35,
            Self::EthernetEncapsulation(_) => 36,
            Self::TcpDefaultTtl(_) => 37,
            Self::TcpKeepaliveInterval(_) => 38,
            Self::TcpKeepaliveGarbage(_) => 39,
            Self::NetworkInformationServiceDomain(_) => 40,
            Self::NetworkInformationServers(_) => 41,
            Self::NetworkTimeProtocolServers(_) => 42,
            Self::VendorSpecificInformation(_) => 43,
            Self::NetbiosOverTcpipNameServer(_) => 44,
            Self::NetbiosOverTcpipDatagramDistributionServer(_) => 45,
            Self::NetbiosOverTcpipNodeType(_) => 46,
            Self::NetbiosOverTcpipScope(_) => 47,
            Self::XWindowSystemFontServer(_) => 48,
            Self::XWindowSystemDisplayManager(_) => 49,
            Self::NetworkInformationServicePlusDomain(_) => 50,
            Self::NetworkInformationServicePlusServers(_) => 51,
            Self::MobileIpHomeAgent(_) => 52,
            Self::SmtpServer(_) => 53,
            Self::Pop3Server(_) => 54,
            Self::NntpServer(_) => 55,
            Self::DefaultWwwServer(_) => 56,
            Self::DefaultFingerServer(_) => 57,
            Self::DefaultIrcServer(_) => 58,
            Self::StreettalkServer(_) => 59,
            Self::StreettalkDirectoryAssistanceServer(_) => 60,
            Self::OptionOverload(_) => 61,
            Self::TftpServerName(_) => 62,
            Self::BootfileName(_) => 63,
            Self::MaxDhcpMessageSize(_) => 64,
            Self::RenewalTimeValue(_) => 65,
            Self::RebindingTimeValue(_) => 66,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn unknown_variant_for_testing() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0 }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { .. } => true,
            _ => false,
        }
    }
}

impl fidl::Persistable for Option_ {}

/// The configurable server parameters.
#[derive(Clone, Debug)]
pub enum Parameter {
    /// The IP addresses to which the server is bound. The vector bound has been
    /// arbitrarily selected as a generous upper limit.
    IpAddrs(Vec<fidl_fuchsia_net::Ipv4Address>),
    /// The pool of addresses managed by a DHCP server and from which leases are
    /// supplied.
    ///
    /// The pool is valid iff all of the following are true:
    ///   1) All fields are present.
    ///   2) The stop address is larger than the start address.
    ///   3) The prefix length is large enough to fit the full range of
    ///      addresses.
    ///
    /// For example, a pool of 4 addresses with a 24 bit subnet mask could be
    /// specified as:
    ///   {
    ///     prefix_length: 24,
    ///     range_start: 192.168.1.2,
    ///     range_stop: 192.168.1.5,
    ///   }
    ///
    /// Changing the address pool will not cancel existing leases because the
    /// DHCP protocol does not provide a mechanism for doing so. Administrators
    /// should take care when changing the address pool for a server with active
    /// leases.
    AddressPool(AddressPool),
    /// The duration of leases offered by the server.
    Lease(LeaseLength),
    /// The client MAC addresses which the server will issue leases to. By
    /// default, the server will not have a permitted MAC list, in which case it
    /// will attempt to issue a lease to every client which requests one. If
    /// permitted_macs has a non-zero length then the server will only respond
    /// to lease requests from clients with  MAC in the list. The vector bound
    /// has been arbitrarily selected as a generous upper limit.
    PermittedMacs(Vec<fidl_fuchsia_net::MacAddress>),
    /// Addresses statically assigned to specific hosts or devices. Typically, a
    /// network administrator will statically assign addresses to always-on
    /// network devices which should always have the same IP address, such as
    /// network printers. The vector bound has been arbitrarily selected as a
    /// generous upper limit.
    StaticallyAssignedAddrs(Vec<StaticAssignment>),
    /// Enables server behavior where the server ARPs an IP address prior to
    /// issuing it in a lease. If the server receives a response, the server
    /// will mark the address as in-use and try again with a different address.
    ArpProbe(bool),
    /// The names of the interface to which the server will listen. If this
    /// vector is empty, the server will listen on all interfaces and will
    /// process incoming DHCP messages regardless of the interface on which they
    /// arrive. If this vector is not empty, then the server will only listen
    /// for incoming DHCP messages on the named interfaces contained by this
    /// vector. The string and vectors bounds have been arbitrarily selected as
    /// generous upper limits.
    BoundDeviceNames(Vec<String>),
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u64 },
}

/// Pattern that matches an unknown `Parameter` member.
#[macro_export]
macro_rules! ParameterUnknown {
    () => {
        _
    };
}

// Custom PartialEq so that unknown variants are not equal to themselves.
impl PartialEq for Parameter {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::IpAddrs(x), Self::IpAddrs(y)) => *x == *y,
            (Self::AddressPool(x), Self::AddressPool(y)) => *x == *y,
            (Self::Lease(x), Self::Lease(y)) => *x == *y,
            (Self::PermittedMacs(x), Self::PermittedMacs(y)) => *x == *y,
            (Self::StaticallyAssignedAddrs(x), Self::StaticallyAssignedAddrs(y)) => *x == *y,
            (Self::ArpProbe(x), Self::ArpProbe(y)) => *x == *y,
            (Self::BoundDeviceNames(x), Self::BoundDeviceNames(y)) => *x == *y,
            _ => false,
        }
    }
}

impl Parameter {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::IpAddrs(_) => 1,
            Self::AddressPool(_) => 2,
            Self::Lease(_) => 3,
            Self::PermittedMacs(_) => 4,
            Self::StaticallyAssignedAddrs(_) => 5,
            Self::ArpProbe(_) => 6,
            Self::BoundDeviceNames(_) => 7,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn unknown_variant_for_testing() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0 }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { .. } => true,
            _ => false,
        }
    }
}

impl fidl::Persistable for Parameter {}

mod internal {
    use super::*;
    unsafe impl fidl::encoding::TypeMarker for NodeTypes {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            1
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            1
        }
    }

    impl fidl::encoding::ValueTypeMarker for NodeTypes {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for NodeTypes {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            if self.bits() & Self::all().bits() != self.bits() {
                return Err(fidl::Error::InvalidBitsValue);
            }
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NodeTypes {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u8>(offset);
            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for ClientExitReason {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for ClientExitReason {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for ClientExitReason
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ClientExitReason {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::ClientAlreadyExistsOnInterface
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for MessageType {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u8>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u8>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for MessageType {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for MessageType {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MessageType {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Dhcpdiscover
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u8>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for OptionCode {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for OptionCode {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for OptionCode {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OptionCode {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::SubnetMask
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for OptionOverloadValue {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u8>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u8>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for OptionOverloadValue {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for OptionOverloadValue
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OptionOverloadValue {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::File
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u8>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for ParameterName {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for ParameterName {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ParameterName {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ParameterName {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::IpAddrs
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ClientOnExitRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ClientOnExitRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ClientOnExitRequest, D>
        for &ClientOnExitRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ClientOnExitRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ClientOnExitRequest, D>::encode(
                (<ClientExitReason as fidl::encoding::ValueTypeMarker>::borrow(&self.reason),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ClientExitReason, D>>
        fidl::encoding::Encode<ClientOnExitRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ClientOnExitRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ClientOnExitRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { reason: fidl::new_empty!(ClientExitReason, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(ClientExitReason, D, &mut self.reason, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ServerGetOptionRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ServerGetOptionRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ServerGetOptionRequest, D> for &ServerGetOptionRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ServerGetOptionRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ServerGetOptionRequest, D>::encode(
                (<OptionCode as fidl::encoding::ValueTypeMarker>::borrow(&self.code),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<OptionCode, D>>
        fidl::encoding::Encode<ServerGetOptionRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ServerGetOptionRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ServerGetOptionRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { code: fidl::new_empty!(OptionCode, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(OptionCode, D, &mut self.code, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ServerGetParameterRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ServerGetParameterRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ServerGetParameterRequest, D> for &ServerGetParameterRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ServerGetParameterRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ServerGetParameterRequest, D>::encode(
                (<ParameterName as fidl::encoding::ValueTypeMarker>::borrow(&self.name),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ParameterName, D>>
        fidl::encoding::Encode<ServerGetParameterRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ServerGetParameterRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ServerGetParameterRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { name: fidl::new_empty!(ParameterName, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(ParameterName, D, &mut self.name, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ServerIsServingResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ServerIsServingResponse {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            1
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            1
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ServerIsServingResponse, D> for &ServerIsServingResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ServerIsServingResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ServerIsServingResponse, D>::encode(
                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.enabled),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
        fidl::encoding::Encode<ServerIsServingResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ServerIsServingResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ServerIsServingResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { enabled: fidl::new_empty!(bool, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(bool, D, &mut self.enabled, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ServerSetOptionRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ServerSetOptionRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ServerSetOptionRequest, D> for &ServerSetOptionRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ServerSetOptionRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ServerSetOptionRequest, D>::encode(
                (<Option_ as fidl::encoding::ValueTypeMarker>::borrow(&self.value),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Option_, D>>
        fidl::encoding::Encode<ServerSetOptionRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ServerSetOptionRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ServerSetOptionRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { value: fidl::new_empty!(Option_, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(Option_, D, &mut self.value, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ServerSetParameterRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ServerSetParameterRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ServerSetParameterRequest, D> for &ServerSetParameterRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ServerSetParameterRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ServerSetParameterRequest, D>::encode(
                (<Parameter as fidl::encoding::ValueTypeMarker>::borrow(&self.value),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Parameter, D>>
        fidl::encoding::Encode<ServerSetParameterRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ServerSetParameterRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ServerSetParameterRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { value: fidl::new_empty!(Parameter, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(Parameter, D, &mut self.value, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ServerGetOptionResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ServerGetOptionResponse {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ServerGetOptionResponse, D> for &ServerGetOptionResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ServerGetOptionResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ServerGetOptionResponse, D>::encode(
                (<Option_ as fidl::encoding::ValueTypeMarker>::borrow(&self.value),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Option_, D>>
        fidl::encoding::Encode<ServerGetOptionResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ServerGetOptionResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ServerGetOptionResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { value: fidl::new_empty!(Option_, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(Option_, D, &mut self.value, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ServerGetParameterResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ServerGetParameterResponse {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ServerGetParameterResponse, D> for &ServerGetParameterResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ServerGetParameterResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ServerGetParameterResponse, D>::encode(
                (<Parameter as fidl::encoding::ValueTypeMarker>::borrow(&self.value),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<Parameter, D>>
        fidl::encoding::Encode<ServerGetParameterResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ServerGetParameterResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ServerGetParameterResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { value: fidl::new_empty!(Parameter, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(Parameter, D, &mut self.value, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ServerListOptionsResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ServerListOptionsResponse {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ServerListOptionsResponse, D> for &ServerListOptionsResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ServerListOptionsResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ServerListOptionsResponse, D>::encode(
                (
                    <fidl::encoding::Vector<Option_, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.options),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::Vector<Option_, 256>, D>,
        > fidl::encoding::Encode<ServerListOptionsResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ServerListOptionsResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ServerListOptionsResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { options: fidl::new_empty!(fidl::encoding::Vector<Option_, 256>, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::Vector<Option_, 256>, D, &mut self.options, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ServerListParametersResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ServerListParametersResponse {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ServerListParametersResponse, D> for &ServerListParametersResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ServerListParametersResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ServerListParametersResponse, D>::encode(
                (
                    <fidl::encoding::Vector<Parameter, 256> as fidl::encoding::ValueTypeMarker>::borrow(&self.parameters),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::Vector<Parameter, 256>, D>,
        > fidl::encoding::Encode<ServerListParametersResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ServerListParametersResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ServerListParametersResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { parameters: fidl::new_empty!(fidl::encoding::Vector<Parameter, 256>, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::Vector<Parameter, 256>, D, &mut self.parameters, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl AddressPool {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.range_stop {
                return 3;
            }
            if let Some(_) = self.range_start {
                return 2;
            }
            if let Some(_) = self.prefix_length {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for AddressPool {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for AddressPool {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<AddressPool, D>
        for &AddressPool
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<AddressPool>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<u8, D>(
                self.prefix_length.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net::Ipv4Address, D>(
                self.range_start.as_ref().map(
                    <fidl_fuchsia_net::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 3 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (3 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net::Ipv4Address, D>(
                self.range_stop.as_ref().map(
                    <fidl_fuchsia_net::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AddressPool {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.prefix_length.get_or_insert_with(|| fidl::new_empty!(u8, D));
                fidl::decode!(u8, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl_fuchsia_net::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .range_start
                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_net::Ipv4Address, D));
                fidl::decode!(
                    fidl_fuchsia_net::Ipv4Address,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 3 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl_fuchsia_net::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .range_stop
                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_net::Ipv4Address, D));
                fidl::decode!(
                    fidl_fuchsia_net::Ipv4Address,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl ConfigurationToRequest {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.dns_servers {
                return 2;
            }
            if let Some(_) = self.routers {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for ConfigurationToRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ConfigurationToRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ConfigurationToRequest, D> for &ConfigurationToRequest
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ConfigurationToRequest>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<bool, D>(
                self.routers.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<bool, D>(
                self.dns_servers.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ConfigurationToRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.routers.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.dns_servers.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl LeaseLength {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.max {
                return 2;
            }
            if let Some(_) = self.default {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for LeaseLength {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for LeaseLength {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<LeaseLength, D>
        for &LeaseLength
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LeaseLength>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<u32, D>(
                self.default.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<u32, D>(
                self.max.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LeaseLength {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.default.get_or_insert_with(|| fidl::new_empty!(u32, D));
                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.max.get_or_insert_with(|| fidl::new_empty!(u32, D));
                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl NewClientParams {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.request_ip_address {
                return 2;
            }
            if let Some(_) = self.configuration_to_request {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for NewClientParams {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NewClientParams {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NewClientParams, D>
        for &NewClientParams
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NewClientParams>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<ConfigurationToRequest, D>(
                self.configuration_to_request
                    .as_ref()
                    .map(<ConfigurationToRequest as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<bool, D>(
                self.request_ip_address
                    .as_ref()
                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NewClientParams {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <ConfigurationToRequest as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .configuration_to_request
                    .get_or_insert_with(|| fidl::new_empty!(ConfigurationToRequest, D));
                fidl::decode!(
                    ConfigurationToRequest,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                    self.request_ip_address.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl StaticAssignment {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.assigned_addr {
                return 2;
            }
            if let Some(_) = self.host {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for StaticAssignment {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for StaticAssignment {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<StaticAssignment, D>
        for &StaticAssignment
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StaticAssignment>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net::MacAddress, D>(
                self.host
                    .as_ref()
                    .map(<fidl_fuchsia_net::MacAddress as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_net::Ipv4Address, D>(
                self.assigned_addr.as_ref().map(
                    <fidl_fuchsia_net::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for StaticAssignment {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl_fuchsia_net::MacAddress as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .host
                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_net::MacAddress, D));
                fidl::decode!(
                    fidl_fuchsia_net::MacAddress,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl_fuchsia_net::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .assigned_addr
                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_net::Ipv4Address, D));
                fidl::decode!(
                    fidl_fuchsia_net::Ipv4Address,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for Option_ {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Option_ {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Option_, D> for &Option_ {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Option_>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            Option_::SubnetMask(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl_fuchsia_net::Ipv4Address, D>(
                    <fidl_fuchsia_net::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::TimeOffset(ref val) => {
                fidl::encoding::encode_in_envelope::<i32, D>(
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::Router(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::TimeServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::NameServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::DomainNameServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::LogServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::CookieServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::LprServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::ImpressServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::ResourceLocationServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::HostName(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::BootFileSize(ref val) => {
                fidl::encoding::encode_in_envelope::<u16, D>(
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::MeritDumpFile(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::DomainName(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::SwapServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl_fuchsia_net::Ipv4Address, D>(
                    <fidl_fuchsia_net::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::RootPath(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::ExtensionsPath(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::IpForwarding(ref val) => {
                fidl::encoding::encode_in_envelope::<bool, D>(
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::NonLocalSourceRouting(ref val) => {
                fidl::encoding::encode_in_envelope::<bool, D>(
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::PolicyFilter(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::MaxDatagramReassemblySize(ref val) => {
                fidl::encoding::encode_in_envelope::<u16, D>(
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::DefaultIpTtl(ref val) => {
                fidl::encoding::encode_in_envelope::<u8, D>(
                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::PathMtuAgingTimeout(ref val) => {
                fidl::encoding::encode_in_envelope::<u32, D>(
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::PathMtuPlateauTable(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<u16, 127>, D>(
                    <fidl::encoding::Vector<u16, 127> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::InterfaceMtu(ref val) => {
                fidl::encoding::encode_in_envelope::<u16, D>(
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::AllSubnetsLocal(ref val) => {
                fidl::encoding::encode_in_envelope::<bool, D>(
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::BroadcastAddress(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl_fuchsia_net::Ipv4Address, D>(
                    <fidl_fuchsia_net::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::PerformMaskDiscovery(ref val) => {
                fidl::encoding::encode_in_envelope::<bool, D>(
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::MaskSupplier(ref val) => {
                fidl::encoding::encode_in_envelope::<bool, D>(
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::PerformRouterDiscovery(ref val) => {
                fidl::encoding::encode_in_envelope::<bool, D>(
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::RouterSolicitationAddress(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl_fuchsia_net::Ipv4Address, D>(
                    <fidl_fuchsia_net::Ipv4Address as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::StaticRoute(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::TrailerEncapsulation(ref val) => {
                fidl::encoding::encode_in_envelope::<bool, D>(
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::ArpCacheTimeout(ref val) => {
                fidl::encoding::encode_in_envelope::<u32, D>(
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::EthernetEncapsulation(ref val) => {
                fidl::encoding::encode_in_envelope::<bool, D>(
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::TcpDefaultTtl(ref val) => {
                fidl::encoding::encode_in_envelope::<u8, D>(
                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::TcpKeepaliveInterval(ref val) => {
                fidl::encoding::encode_in_envelope::<u32, D>(
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::TcpKeepaliveGarbage(ref val) => {
                fidl::encoding::encode_in_envelope::<bool, D>(
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::NetworkInformationServiceDomain(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::NetworkInformationServers(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::NetworkTimeProtocolServers(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::VendorSpecificInformation(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<u8, 255>, D>(
                    <fidl::encoding::Vector<u8, 255> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::NetbiosOverTcpipNameServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::NetbiosOverTcpipDatagramDistributionServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::NetbiosOverTcpipNodeType(ref val) => {
                fidl::encoding::encode_in_envelope::<NodeTypes, D>(
                    <NodeTypes as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::NetbiosOverTcpipScope(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::XWindowSystemFontServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::XWindowSystemDisplayManager(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::NetworkInformationServicePlusDomain(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::NetworkInformationServicePlusServers(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::MobileIpHomeAgent(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::SmtpServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::Pop3Server(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::NntpServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::DefaultWwwServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::DefaultFingerServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::DefaultIrcServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::StreettalkServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::StreettalkDirectoryAssistanceServer(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::OptionOverload(ref val) => {
                fidl::encoding::encode_in_envelope::<OptionOverloadValue, D>(
                    <OptionOverloadValue as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::TftpServerName(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::BootfileName(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::BoundedString<255>, D>(
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::MaxDhcpMessageSize(ref val) => {
                fidl::encoding::encode_in_envelope::<u16, D>(
                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::RenewalTimeValue(ref val) => {
                fidl::encoding::encode_in_envelope::<u32, D>(
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::RebindingTimeValue(ref val) => {
                fidl::encoding::encode_in_envelope::<u32, D>(
                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Option_::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
        }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Option_ {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
            1 => <fidl_fuchsia_net::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            2 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            3 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            4 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            5 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            6 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            7 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            8 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            9 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            10 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            11 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            12 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            13 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            14 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            15 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            16 => <fidl_fuchsia_net::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            17 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            18 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            19 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            20 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            21 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            22 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            23 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            24 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            25 => <fidl::encoding::Vector<u16, 127> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            26 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            27 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            28 => <fidl_fuchsia_net::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            29 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            30 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            31 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            32 => <fidl_fuchsia_net::Ipv4Address as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            33 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            34 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            35 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            36 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            37 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            38 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            39 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            40 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            41 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            42 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            43 => <fidl::encoding::Vector<u8, 255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            44 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            45 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            46 => <NodeTypes as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            47 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            48 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            49 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            50 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            51 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            52 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            53 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            54 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            55 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            56 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            57 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            58 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            59 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            60 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            61 => <OptionOverloadValue as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            62 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            63 => <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            64 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            65 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            66 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            0 => return Err(fidl::Error::UnknownUnionTag),
            _ => num_bytes as usize,
        };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::SubnetMask(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self =
                            Option_::SubnetMask(fidl::new_empty!(fidl_fuchsia_net::Ipv4Address, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::SubnetMask(ref mut val) = self {
                        fidl::decode!(
                            fidl_fuchsia_net::Ipv4Address,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::TimeOffset(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::TimeOffset(fidl::new_empty!(i32, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::TimeOffset(ref mut val) = self {
                        fidl::decode!(i32, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::Router(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::Router(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::Router(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                4 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::TimeServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::TimeServer(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::TimeServer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                5 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NameServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::NameServer(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NameServer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                6 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::DomainNameServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::DomainNameServer(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::DomainNameServer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                7 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::LogServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::LogServer(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::LogServer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                8 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::CookieServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::CookieServer(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::CookieServer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                9 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::LprServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::LprServer(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::LprServer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                10 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::ImpressServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::ImpressServer(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::ImpressServer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                11 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::ResourceLocationServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::ResourceLocationServer(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::ResourceLocationServer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                12 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::HostName(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::HostName(fidl::new_empty!(
                            fidl::encoding::BoundedString<255>,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::HostName(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::BoundedString<255>,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                13 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::BootFileSize(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::BootFileSize(fidl::new_empty!(u16, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::BootFileSize(ref mut val) = self {
                        fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                14 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::MeritDumpFile(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::MeritDumpFile(fidl::new_empty!(
                            fidl::encoding::BoundedString<255>,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::MeritDumpFile(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::BoundedString<255>,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                15 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::DomainName(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::DomainName(fidl::new_empty!(
                            fidl::encoding::BoundedString<255>,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::DomainName(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::BoundedString<255>,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                16 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::SwapServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self =
                            Option_::SwapServer(fidl::new_empty!(fidl_fuchsia_net::Ipv4Address, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::SwapServer(ref mut val) = self {
                        fidl::decode!(
                            fidl_fuchsia_net::Ipv4Address,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                17 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::RootPath(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::RootPath(fidl::new_empty!(
                            fidl::encoding::BoundedString<255>,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::RootPath(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::BoundedString<255>,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                18 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::ExtensionsPath(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::ExtensionsPath(fidl::new_empty!(
                            fidl::encoding::BoundedString<255>,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::ExtensionsPath(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::BoundedString<255>,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                19 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::IpForwarding(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::IpForwarding(fidl::new_empty!(bool, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::IpForwarding(ref mut val) = self {
                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                20 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NonLocalSourceRouting(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::NonLocalSourceRouting(fidl::new_empty!(bool, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NonLocalSourceRouting(ref mut val) = self {
                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                21 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::PolicyFilter(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::PolicyFilter(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::PolicyFilter(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                22 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::MaxDatagramReassemblySize(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::MaxDatagramReassemblySize(fidl::new_empty!(u16, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::MaxDatagramReassemblySize(ref mut val) = self {
                        fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                23 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::DefaultIpTtl(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::DefaultIpTtl(fidl::new_empty!(u8, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::DefaultIpTtl(ref mut val) = self {
                        fidl::decode!(u8, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                24 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::PathMtuAgingTimeout(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::PathMtuAgingTimeout(fidl::new_empty!(u32, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::PathMtuAgingTimeout(ref mut val) = self {
                        fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                25 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::PathMtuPlateauTable(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::PathMtuPlateauTable(
                            fidl::new_empty!(fidl::encoding::Vector<u16, 127>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::PathMtuPlateauTable(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<u16, 127>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                26 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::InterfaceMtu(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::InterfaceMtu(fidl::new_empty!(u16, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::InterfaceMtu(ref mut val) = self {
                        fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                27 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::AllSubnetsLocal(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::AllSubnetsLocal(fidl::new_empty!(bool, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::AllSubnetsLocal(ref mut val) = self {
                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                28 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::BroadcastAddress(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::BroadcastAddress(fidl::new_empty!(
                            fidl_fuchsia_net::Ipv4Address,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::BroadcastAddress(ref mut val) = self {
                        fidl::decode!(
                            fidl_fuchsia_net::Ipv4Address,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                29 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::PerformMaskDiscovery(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::PerformMaskDiscovery(fidl::new_empty!(bool, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::PerformMaskDiscovery(ref mut val) = self {
                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                30 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::MaskSupplier(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::MaskSupplier(fidl::new_empty!(bool, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::MaskSupplier(ref mut val) = self {
                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                31 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::PerformRouterDiscovery(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::PerformRouterDiscovery(fidl::new_empty!(bool, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::PerformRouterDiscovery(ref mut val) = self {
                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                32 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::RouterSolicitationAddress(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::RouterSolicitationAddress(fidl::new_empty!(
                            fidl_fuchsia_net::Ipv4Address,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::RouterSolicitationAddress(ref mut val) = self {
                        fidl::decode!(
                            fidl_fuchsia_net::Ipv4Address,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                33 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::StaticRoute(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::StaticRoute(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::StaticRoute(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                34 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::TrailerEncapsulation(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::TrailerEncapsulation(fidl::new_empty!(bool, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::TrailerEncapsulation(ref mut val) = self {
                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                35 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::ArpCacheTimeout(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::ArpCacheTimeout(fidl::new_empty!(u32, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::ArpCacheTimeout(ref mut val) = self {
                        fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                36 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::EthernetEncapsulation(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::EthernetEncapsulation(fidl::new_empty!(bool, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::EthernetEncapsulation(ref mut val) = self {
                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                37 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::TcpDefaultTtl(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::TcpDefaultTtl(fidl::new_empty!(u8, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::TcpDefaultTtl(ref mut val) = self {
                        fidl::decode!(u8, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                38 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::TcpKeepaliveInterval(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::TcpKeepaliveInterval(fidl::new_empty!(u32, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::TcpKeepaliveInterval(ref mut val) = self {
                        fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                39 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::TcpKeepaliveGarbage(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::TcpKeepaliveGarbage(fidl::new_empty!(bool, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::TcpKeepaliveGarbage(ref mut val) = self {
                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                40 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NetworkInformationServiceDomain(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::NetworkInformationServiceDomain(fidl::new_empty!(
                            fidl::encoding::BoundedString<255>,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NetworkInformationServiceDomain(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::BoundedString<255>,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                41 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NetworkInformationServers(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::NetworkInformationServers(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NetworkInformationServers(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                42 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NetworkTimeProtocolServers(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::NetworkTimeProtocolServers(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NetworkTimeProtocolServers(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                43 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::VendorSpecificInformation(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::VendorSpecificInformation(
                            fidl::new_empty!(fidl::encoding::Vector<u8, 255>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::VendorSpecificInformation(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<u8, 255>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                44 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NetbiosOverTcpipNameServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::NetbiosOverTcpipNameServer(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NetbiosOverTcpipNameServer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                45 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NetbiosOverTcpipDatagramDistributionServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::NetbiosOverTcpipDatagramDistributionServer(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NetbiosOverTcpipDatagramDistributionServer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                46 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NetbiosOverTcpipNodeType(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::NetbiosOverTcpipNodeType(fidl::new_empty!(NodeTypes, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NetbiosOverTcpipNodeType(ref mut val) = self {
                        fidl::decode!(NodeTypes, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                47 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NetbiosOverTcpipScope(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::NetbiosOverTcpipScope(fidl::new_empty!(
                            fidl::encoding::BoundedString<255>,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NetbiosOverTcpipScope(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::BoundedString<255>,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                48 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::XWindowSystemFontServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::XWindowSystemFontServer(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::XWindowSystemFontServer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                49 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::XWindowSystemDisplayManager(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::XWindowSystemDisplayManager(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::XWindowSystemDisplayManager(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                50 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NetworkInformationServicePlusDomain(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::NetworkInformationServicePlusDomain(fidl::new_empty!(
                            fidl::encoding::BoundedString<255>,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NetworkInformationServicePlusDomain(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::BoundedString<255>,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                51 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NetworkInformationServicePlusServers(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::NetworkInformationServicePlusServers(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NetworkInformationServicePlusServers(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                52 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::MobileIpHomeAgent(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::MobileIpHomeAgent(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::MobileIpHomeAgent(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                53 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::SmtpServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::SmtpServer(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::SmtpServer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                54 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::Pop3Server(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::Pop3Server(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::Pop3Server(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                55 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NntpServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::NntpServer(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::NntpServer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                56 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::DefaultWwwServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::DefaultWwwServer(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::DefaultWwwServer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                57 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::DefaultFingerServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::DefaultFingerServer(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::DefaultFingerServer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                58 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::DefaultIrcServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::DefaultIrcServer(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::DefaultIrcServer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                59 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::StreettalkServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::StreettalkServer(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::StreettalkServer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                60 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::StreettalkDirectoryAssistanceServer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::StreettalkDirectoryAssistanceServer(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::StreettalkDirectoryAssistanceServer(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 63>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                61 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::OptionOverload(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::OptionOverload(fidl::new_empty!(OptionOverloadValue, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::OptionOverload(ref mut val) = self {
                        fidl::decode!(OptionOverloadValue, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                62 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::TftpServerName(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::TftpServerName(fidl::new_empty!(
                            fidl::encoding::BoundedString<255>,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::TftpServerName(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::BoundedString<255>,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                63 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::BootfileName(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::BootfileName(fidl::new_empty!(
                            fidl::encoding::BoundedString<255>,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::BootfileName(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::BoundedString<255>,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                64 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::MaxDhcpMessageSize(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::MaxDhcpMessageSize(fidl::new_empty!(u16, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::MaxDhcpMessageSize(ref mut val) = self {
                        fidl::decode!(u16, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                65 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::RenewalTimeValue(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::RenewalTimeValue(fidl::new_empty!(u32, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::RenewalTimeValue(ref mut val) = self {
                        fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                66 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::RebindingTimeValue(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Option_::RebindingTimeValue(fidl::new_empty!(u32, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Option_::RebindingTimeValue(ref mut val) = self {
                        fidl::decode!(u32, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = Option_::__SourceBreaking { unknown_ordinal: ordinal };
                }
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for Parameter {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Parameter {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Parameter, D>
        for &Parameter
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Parameter>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            Parameter::IpAddrs(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 256>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 256> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Parameter::AddressPool(ref val) => {
                fidl::encoding::encode_in_envelope::<AddressPool, D>(
                    <AddressPool as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Parameter::Lease(ref val) => {
                fidl::encoding::encode_in_envelope::<LeaseLength, D>(
                    <LeaseLength as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Parameter::PermittedMacs(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl_fuchsia_net::MacAddress, 256>, D>(
                    <fidl::encoding::Vector<fidl_fuchsia_net::MacAddress, 256> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Parameter::StaticallyAssignedAddrs(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<StaticAssignment, 256>, D>(
                    <fidl::encoding::Vector<StaticAssignment, 256> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Parameter::ArpProbe(ref val) => {
                fidl::encoding::encode_in_envelope::<bool, D>(
                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Parameter::BoundDeviceNames(ref val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 256>, D>(
                    <fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 256> as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            Parameter::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
        }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Parameter {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
            1 => <fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 256> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            2 => <AddressPool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            3 => <LeaseLength as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            4 => <fidl::encoding::Vector<fidl_fuchsia_net::MacAddress, 256> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            5 => <fidl::encoding::Vector<StaticAssignment, 256> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            6 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            7 => <fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 256> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            0 => return Err(fidl::Error::UnknownUnionTag),
            _ => num_bytes as usize,
        };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Parameter::IpAddrs(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Parameter::IpAddrs(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 256>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Parameter::IpAddrs(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::Ipv4Address, 256>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Parameter::AddressPool(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Parameter::AddressPool(fidl::new_empty!(AddressPool, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Parameter::AddressPool(ref mut val) = self {
                        fidl::decode!(AddressPool, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Parameter::Lease(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Parameter::Lease(fidl::new_empty!(LeaseLength, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Parameter::Lease(ref mut val) = self {
                        fidl::decode!(LeaseLength, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                4 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Parameter::PermittedMacs(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Parameter::PermittedMacs(
                            fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net::MacAddress, 256>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Parameter::PermittedMacs(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net::MacAddress, 256>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                5 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Parameter::StaticallyAssignedAddrs(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Parameter::StaticallyAssignedAddrs(
                            fidl::new_empty!(fidl::encoding::Vector<StaticAssignment, 256>, D),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Parameter::StaticallyAssignedAddrs(ref mut val) = self {
                        fidl::decode!(fidl::encoding::Vector<StaticAssignment, 256>, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                6 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Parameter::ArpProbe(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Parameter::ArpProbe(fidl::new_empty!(bool, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Parameter::ArpProbe(ref mut val) = self {
                        fidl::decode!(bool, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                7 => {
                    #[allow(irrefutable_let_patterns)]
                    if let Parameter::BoundDeviceNames(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = Parameter::BoundDeviceNames(fidl::new_empty!(
                            fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 256>,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let Parameter::BoundDeviceNames(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::Vector<fidl::encoding::BoundedString<256>, 256>,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = Parameter::__SourceBreaking { unknown_ordinal: ordinal };
                }
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }
}