fidl_fuchsia_posix_socket/

fidl_fuchsia_posix_socket.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::client::QueryResponseFut;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use fidl::endpoints::{ControlHandle as _, Responder as _};
pub use fidl_fuchsia_posix_socket__common::*;
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

#[derive(Debug, PartialEq)]
pub struct ProviderDatagramSocketWithOptionsRequest {
    pub domain: Domain,
    pub proto: DatagramSocketProtocol,
    pub opts: SocketCreationOptions,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ProviderDatagramSocketWithOptionsRequest
{
}

#[derive(Debug, PartialEq)]
pub struct ProviderStreamSocketWithOptionsRequest {
    pub domain: Domain,
    pub proto: StreamSocketProtocol,
    pub opts: SocketCreationOptions,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ProviderStreamSocketWithOptionsRequest
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ProviderDatagramSocketDeprecatedResponse {
    pub s: fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ProviderDatagramSocketDeprecatedResponse
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ProviderStreamSocketWithOptionsResponse {
    pub s: fidl::endpoints::ClientEnd<StreamSocketMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ProviderStreamSocketWithOptionsResponse
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ProviderStreamSocketResponse {
    pub s: fidl::endpoints::ClientEnd<StreamSocketMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ProviderStreamSocketResponse
{
}

#[derive(Debug, PartialEq)]
pub struct StreamSocketAcceptResponse {
    pub addr: Option<Box<fidl_fuchsia_net::SocketAddress>>,
    pub s: fidl::endpoints::ClientEnd<StreamSocketMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for StreamSocketAcceptResponse
{
}

#[derive(Debug, Default, PartialEq)]
pub struct DatagramSocketDescribeResponse {
    /// `ZX_SOCKET_DATAGRAM` on which data is sent and received.
    pub socket: Option<fidl::Socket>,
    /// Size of the buffer used to receive Tx metadata.
    pub tx_meta_buf_size: Option<u64>,
    /// Size of the buffer used to receive Rx metadata.
    pub rx_meta_buf_size: Option<u64>,
    /// Identifies the version of the protocol used to encode and decode
    /// metadata sent alongside payloads over the socket.
    pub metadata_encoding_protocol_version: Option<UdpMetadataEncodingProtocolVersion>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for DatagramSocketDescribeResponse
{
}

#[derive(Debug, Default, PartialEq)]
pub struct DatagramSocketRecvMsgPostflightResponse {
    /// Represents the validity of this structure.
    ///
    /// The structure is invalid if the peer is closed.
    pub validity: Option<fidl::EventPair>,
    /// Identifies whether the `SO_TIMESTAMP` or `SO_TIMESTAMPNS` control messages are
    /// requested.
    pub timestamp: Option<TimestampOption>,
    /// Identifies the status (requested or not) of up to 32 control messages.
    /// This set size should be large enough to signal the status of all cmsgs supported
    /// by POSIX systems as of 2022. If that changes, the set can be extended by adding
    /// additional bits fields.
    pub requests: Option<CmsgRequests>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for DatagramSocketRecvMsgPostflightResponse
{
}

#[derive(Debug, Default, PartialEq)]
pub struct DatagramSocketSendMsgPreflightResponse {
    /// The validated destination address.
    ///
    /// Present only in response to an unset `to` addreess.
    pub to: Option<fidl_fuchsia_net::SocketAddress>,
    /// Represents the validity of this structure.
    ///
    /// The structure is invalid if any of the elements' peer is closed.
    /// Datagrams sent with the associated metadata after invalidation will be
    /// silently dropped.
    pub validity: Option<Vec<fidl::EventPair>>,
    /// The maximum datagram size that can be sent.
    ///
    /// Datagrams exceeding this will be silently dropped.
    pub maximum_size: Option<u32>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for DatagramSocketSendMsgPreflightResponse
{
}

/// Options that can be provided at socket creation.
#[derive(Debug, Default, PartialEq)]
pub struct SocketCreationOptions {
    /// The marks for the created socket. If a mark is missing from the table,
    /// it will remain unset for the created socket.
    pub marks: Option<fidl_fuchsia_net::Marks>,
    /// A wake group to add the socket to on creation.
    ///
    /// If absent, the socket is not added to any wake group. If the token
    /// provided does not correspond to an existing wake group, socket creation
    /// succeeds, but the socket is not added to any wake group. This makes it
    /// easier for clients to avoid a race between shutting down their wake
    /// group and creating a new socket.
    pub group: Option<fidl_fuchsia_net_resources::WakeGroupToken>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for SocketCreationOptions {}

#[derive(Debug, Default, PartialEq)]
pub struct StreamSocketDescribeResponse {
    /// `ZX_SOCKET_STREAM` on which data is sent and received.
    pub socket: Option<fidl::Socket>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for StreamSocketDescribeResponse
{
}

#[derive(Debug, Default, PartialEq)]
pub struct SynchronousDatagramSocketDescribeResponse {
    /// Signals additional information about the state of the socket such as
    /// readiness or shutdown-ness.
    pub event: Option<fidl::EventPair>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for SynchronousDatagramSocketDescribeResponse
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum ProviderDatagramSocketWithOptionsResponse {
    DatagramSocket(fidl::endpoints::ClientEnd<DatagramSocketMarker>),
    SynchronousDatagramSocket(fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>),
}

impl ProviderDatagramSocketWithOptionsResponse {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::DatagramSocket(_) => 1,
            Self::SynchronousDatagramSocket(_) => 2,
        }
    }
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ProviderDatagramSocketWithOptionsResponse
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum ProviderDatagramSocketResponse {
    DatagramSocket(fidl::endpoints::ClientEnd<DatagramSocketMarker>),
    SynchronousDatagramSocket(fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>),
}

impl ProviderDatagramSocketResponse {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::DatagramSocket(_) => 1,
            Self::SynchronousDatagramSocket(_) => 2,
        }
    }
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ProviderDatagramSocketResponse
{
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct BaseDatagramSocketMarker;

impl fidl::endpoints::ProtocolMarker for BaseDatagramSocketMarker {
    type Proxy = BaseDatagramSocketProxy;
    type RequestStream = BaseDatagramSocketRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = BaseDatagramSocketSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) BaseDatagramSocket";
}
pub type BaseDatagramSocketGetInfoResult =
    Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>;

pub trait BaseDatagramSocketProxyInterface: Send + Sync {
    fn r#clone(
        &self,
        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error>;
    type CloseResponseFut: std::future::Future<
            Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
        > + Send;
    fn r#close(&self) -> Self::CloseResponseFut;
    type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
    fn r#query(&self) -> Self::QueryResponseFut;
    type SetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketSetReuseAddressResult, fidl::Error>>
        + Send;
    fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
    type GetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketGetReuseAddressResult, fidl::Error>>
        + Send;
    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
    type GetErrorResponseFut: std::future::Future<Output = Result<BaseSocketGetErrorResult, fidl::Error>>
        + Send;
    fn r#get_error(&self) -> Self::GetErrorResponseFut;
    type SetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketSetBroadcastResult, fidl::Error>>
        + Send;
    fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
    type GetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketGetBroadcastResult, fidl::Error>>
        + Send;
    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
    type SetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetSendBufferResult, fidl::Error>>
        + Send;
    fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
    type GetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetSendBufferResult, fidl::Error>>
        + Send;
    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
    type SetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetReceiveBufferResult, fidl::Error>>
        + Send;
    fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
    type GetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetReceiveBufferResult, fidl::Error>>
        + Send;
    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
    type SetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketSetKeepAliveResult, fidl::Error>>
        + Send;
    fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
    type GetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketGetKeepAliveResult, fidl::Error>>
        + Send;
    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
    type SetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketSetOutOfBandInlineResult, fidl::Error>>
        + Send;
    fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
    type GetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketGetOutOfBandInlineResult, fidl::Error>>
        + Send;
    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
    type SetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketSetNoCheckResult, fidl::Error>>
        + Send;
    fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
    type GetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketGetNoCheckResult, fidl::Error>>
        + Send;
    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
    type SetLingerResponseFut: std::future::Future<Output = Result<BaseSocketSetLingerResult, fidl::Error>>
        + Send;
    fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
    type GetLingerResponseFut: std::future::Future<Output = Result<BaseSocketGetLingerResult, fidl::Error>>
        + Send;
    fn r#get_linger(&self) -> Self::GetLingerResponseFut;
    type SetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketSetReusePortResult, fidl::Error>>
        + Send;
    fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
    type GetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketGetReusePortResult, fidl::Error>>
        + Send;
    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
    type GetAcceptConnResponseFut: std::future::Future<Output = Result<BaseSocketGetAcceptConnResult, fidl::Error>>
        + Send;
    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
    type SetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToDeviceResult, fidl::Error>>
        + Send;
    fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
    type GetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToDeviceResult, fidl::Error>>
        + Send;
    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
    type SetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error>>
        + Send;
    fn r#set_bind_to_interface_index(&self, value: u64)
    -> Self::SetBindToInterfaceIndexResponseFut;
    type GetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error>>
        + Send;
    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
    type SetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketSetTimestampResult, fidl::Error>>
        + Send;
    fn r#set_timestamp(&self, value: TimestampOption) -> Self::SetTimestampResponseFut;
    type GetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketGetTimestampResult, fidl::Error>>
        + Send;
    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
    type SetMarkResponseFut: std::future::Future<Output = Result<BaseSocketSetMarkResult, fidl::Error>>
        + Send;
    fn r#set_mark(
        &self,
        domain: fidl_fuchsia_net::MarkDomain,
        mark: &OptionalUint32,
    ) -> Self::SetMarkResponseFut;
    type GetMarkResponseFut: std::future::Future<Output = Result<BaseSocketGetMarkResult, fidl::Error>>
        + Send;
    fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
    type GetCookieResponseFut: std::future::Future<Output = Result<BaseSocketGetCookieResult, fidl::Error>>
        + Send;
    fn r#get_cookie(&self) -> Self::GetCookieResponseFut;
    type BindResponseFut: std::future::Future<Output = Result<BaseNetworkSocketBindResult, fidl::Error>>
        + Send;
    fn r#bind(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut;
    type ConnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketConnectResult, fidl::Error>>
        + Send;
    fn r#connect(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut;
    type DisconnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDisconnectResult, fidl::Error>>
        + Send;
    fn r#disconnect(&self) -> Self::DisconnectResponseFut;
    type GetSockNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetSockNameResult, fidl::Error>>
        + Send;
    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut;
    type GetPeerNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetPeerNameResult, fidl::Error>>
        + Send;
    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut;
    type ShutdownResponseFut: std::future::Future<Output = Result<BaseNetworkSocketShutdownResult, fidl::Error>>
        + Send;
    fn r#shutdown(&self, mode: ShutdownMode) -> Self::ShutdownResponseFut;
    type SetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>>
        + Send;
    fn r#set_ip_type_of_service(&self, value: u8) -> Self::SetIpTypeOfServiceResponseFut;
    type GetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>>
        + Send;
    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut;
    type SetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTtlResult, fidl::Error>>
        + Send;
    fn r#set_ip_ttl(&self, value: &OptionalUint8) -> Self::SetIpTtlResponseFut;
    type GetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTtlResult, fidl::Error>>
        + Send;
    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut;
    type SetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>>
        + Send;
    fn r#set_ip_packet_info(&self, value: bool) -> Self::SetIpPacketInfoResponseFut;
    type GetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>>
        + Send;
    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut;
    type SetIpReceiveTypeOfServiceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error>,
        > + Send;
    fn r#set_ip_receive_type_of_service(
        &self,
        value: bool,
    ) -> Self::SetIpReceiveTypeOfServiceResponseFut;
    type GetIpReceiveTypeOfServiceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error>,
        > + Send;
    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut;
    type SetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>>
        + Send;
    fn r#set_ip_receive_ttl(&self, value: bool) -> Self::SetIpReceiveTtlResponseFut;
    type GetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>>
        + Send;
    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut;
    type SetIpMulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#set_ip_multicast_interface(
        &self,
        iface: u64,
        address: &fidl_fuchsia_net::Ipv4Address,
    ) -> Self::SetIpMulticastInterfaceResponseFut;
    type GetIpMulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut;
    type SetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>>
        + Send;
    fn r#set_ip_multicast_ttl(&self, value: &OptionalUint8) -> Self::SetIpMulticastTtlResponseFut;
    type GetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>>
        + Send;
    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut;
    type SetIpMulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#set_ip_multicast_loopback(&self, value: bool) -> Self::SetIpMulticastLoopbackResponseFut;
    type GetIpMulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut;
    type AddIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error>>
        + Send;
    fn r#add_ip_membership(
        &self,
        membership: &IpMulticastMembership,
    ) -> Self::AddIpMembershipResponseFut;
    type DropIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error>>
        + Send;
    fn r#drop_ip_membership(
        &self,
        membership: &IpMulticastMembership,
    ) -> Self::DropIpMembershipResponseFut;
    type SetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error>>
        + Send;
    fn r#set_ip_transparent(&self, value: bool) -> Self::SetIpTransparentResponseFut;
    type GetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error>>
        + Send;
    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut;
    type SetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
            Output = Result<
                BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
                fidl::Error,
            >,
        > + Send;
    fn r#set_ip_receive_original_destination_address(
        &self,
        value: bool,
    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut;
    type GetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
            Output = Result<
                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
                fidl::Error,
            >,
        > + Send;
    fn r#get_ip_receive_original_destination_address(
        &self,
    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut;
    type AddIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>>
        + Send;
    fn r#add_ipv6_membership(
        &self,
        membership: &Ipv6MulticastMembership,
    ) -> Self::AddIpv6MembershipResponseFut;
    type DropIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>>
        + Send;
    fn r#drop_ipv6_membership(
        &self,
        membership: &Ipv6MulticastMembership,
    ) -> Self::DropIpv6MembershipResponseFut;
    type SetIpv6MulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_multicast_interface(
        &self,
        value: u64,
    ) -> Self::SetIpv6MulticastInterfaceResponseFut;
    type GetIpv6MulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut;
    type SetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>>
        + Send;
    fn r#set_ipv6_unicast_hops(&self, value: &OptionalUint8)
    -> Self::SetIpv6UnicastHopsResponseFut;
    type GetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>>
        + Send;
    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut;
    type SetIpv6ReceiveHopLimitResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_receive_hop_limit(&self, value: bool) -> Self::SetIpv6ReceiveHopLimitResponseFut;
    type GetIpv6ReceiveHopLimitResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut;
    type SetIpv6MulticastHopsResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_multicast_hops(
        &self,
        value: &OptionalUint8,
    ) -> Self::SetIpv6MulticastHopsResponseFut;
    type GetIpv6MulticastHopsResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut;
    type SetIpv6MulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_multicast_loopback(
        &self,
        value: bool,
    ) -> Self::SetIpv6MulticastLoopbackResponseFut;
    type GetIpv6MulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut;
    type SetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error>>
        + Send;
    fn r#set_ipv6_only(&self, value: bool) -> Self::SetIpv6OnlyResponseFut;
    type GetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error>>
        + Send;
    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut;
    type SetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_receive_traffic_class(
        &self,
        value: bool,
    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut;
    type GetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut;
    type SetIpv6TrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_traffic_class(
        &self,
        value: &OptionalUint8,
    ) -> Self::SetIpv6TrafficClassResponseFut;
    type GetIpv6TrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut;
    type SetIpv6ReceivePacketInfoResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_receive_packet_info(
        &self,
        value: bool,
    ) -> Self::SetIpv6ReceivePacketInfoResponseFut;
    type GetIpv6ReceivePacketInfoResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut;
    type GetOriginalDestinationResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error>,
        > + Send;
    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut;
    type GetInfoResponseFut: std::future::Future<Output = Result<BaseDatagramSocketGetInfoResult, fidl::Error>>
        + Send;
    fn r#get_info(&self) -> Self::GetInfoResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct BaseDatagramSocketSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for BaseDatagramSocketSynchronousProxy {
    type Proxy = BaseDatagramSocketProxy;
    type Protocol = BaseDatagramSocketMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl BaseDatagramSocketSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <BaseDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<BaseDatagramSocketEvent, fidl::Error> {
        BaseDatagramSocketEvent::decode(self.client.wait_for_event(deadline)?)
    }

    pub fn r#clone(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_unknown::QueryableQueryResponse,
        >(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.protocol)
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#set_reuse_address(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetReuseAddressRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x1fd74ee8b9a4a876,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#get_reuse_address(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetReuseAddressResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Get `SOL_SOCKET` -> `SO_ERROR`.
    /// Returns the last error if there is an error set on the socket.
    pub fn r#get_error(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x5aad39b33e5f6ebb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#set_broadcast(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetBroadcastRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x6023e081ce3cd947,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#get_broadcast(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetBroadcastResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x68796fc556f9780d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#set_send_buffer(
        &self,
        mut value_bytes: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetSendBufferRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value_bytes,),
                0x756eac32d73a7a70,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#get_send_buffer(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetSendBufferResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value_bytes))
    }

    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#set_receive_buffer(
        &self,
        mut value_bytes: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseSocketSetReceiveBufferRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value_bytes,),
                    0x6b0cf2f1919c7001,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#get_receive_buffer(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetReceiveBufferResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value_bytes))
    }

    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#set_keep_alive(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetKeepAliveRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x572df8f0b920d2c7,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#get_keep_alive(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetKeepAliveResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x2dd29d3215f2c9d2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#set_out_of_band_inline(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseSocketSetOutOfBandInlineRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x3ecb49968bee439,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#get_out_of_band_inline(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetOutOfBandInlineResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#set_no_check(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetNoCheckRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x6bbf00c53a4c78c2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#get_no_check(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetNoCheckResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x2cd4249286417694,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#set_linger(
        &self,
        mut linger: bool,
        mut length_secs: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetLingerRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (linger, length_secs),
                0x45386351246e998e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#get_linger(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetLingerResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x48eb20fc5ccb0e45,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| (x.linger, x.length_secs)))
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#set_reuse_port(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetReusePortRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x24dd3e5cb36d9ccb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#get_reuse_port(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetReusePortResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x7a112c1ab54ff828,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
    pub fn r#get_accept_conn(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetAcceptConnResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#set_bind_to_device(
        &self,
        mut value: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetBindToDeviceRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x2118b483f28aafc4,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#get_bind_to_device(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetBindToDeviceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    /// If `value` is 0, this clears the bound interface.
    pub fn r#set_bind_to_interface_index(
        &self,
        mut value: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x6e387a0def00821,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    pub fn r#get_bind_to_interface_index(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetBindToInterfaceIndexResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#set_timestamp(
        &self,
        mut value: TimestampOption,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetTimestampRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x285d6516c263d839,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#get_timestamp(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetTimestampResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x49f2fffbbcc2bd27,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be set independently in each domain.
    pub fn r#set_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        mut mark: &OptionalUint32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetMarkRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (domain, mark),
                0x6ead6de09f653236,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be retrieved independently in each domain.
    pub fn r#get_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketGetMarkRequest, fidl::encoding::ResultType<
                BaseSocketGetMarkResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (domain,),
                0x57a2752c61d93d47,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.mark))
    }

    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
    pub fn r#get_cookie(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetCookieResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetCookieResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x2c2f47fd8f924e52,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Sets the local address used for the socket.
    pub fn r#bind(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketBindRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (addr,),
                0x4bc6400ae92125d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Initiates a connection to a remote address.
    pub fn r#connect(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketConnectRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (addr,),
                0x5f05f19bfdd38871,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Clears connection information from this socket.
    pub fn r#disconnect(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x74e63b91f7b29b2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Retrieves the local socket address.
    pub fn r#get_sock_name(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetSockNameResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x475f23f84a1a4f85, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.addr))
    }

    /// Retrieves the remote socket address.
    pub fn r#get_peer_name(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetPeerNameResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x1ffecf4bd5b6432e, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.addr))
    }

    /// Shuts down part of the socket.
    pub fn r#shutdown(
        &self,
        mut mode: ShutdownMode,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketShutdownRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (mode,),
                0x247f38b6db68c336,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IP` -> `IP_TOS`.
    pub fn r#set_ip_type_of_service(
        &self,
        mut value: u8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpTypeOfServiceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x995c600475b6d46,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_TOS`.
    pub fn r#get_ip_type_of_service(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpTypeOfServiceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x3814a04259f75fcb, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_TTL`.
    pub fn r#set_ip_ttl(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketSetIpTtlRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x29e2424b433ae1ef,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_TTL`.
    pub fn r#get_ip_ttl(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpTtlResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x47e47fa1f24da471, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#set_ip_packet_info(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x392d16bee20c0e16,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#get_ip_packet_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpPacketInfoResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x54b505f242280740, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#set_ip_receive_type_of_service(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x6c4f6714995f84ef,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#get_ip_receive_type_of_service(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4158ba7dc2795960, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#set_ip_receive_ttl(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x46f15be0ce0ab82b,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#get_ip_receive_ttl(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpReceiveTtlResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x678ddd5a5dfa2eb5, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#set_ip_multicast_interface(
        &self,
        mut iface: u64,
        mut address: &fidl_fuchsia_net::Ipv4Address,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpMulticastInterfaceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (iface, address,),
            0x752fbfa9b12befe,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#get_ip_multicast_interface(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpMulticastInterfaceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x320bd14c4df046c4, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#set_ip_multicast_ttl(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x63134d53772916a1,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#get_ip_multicast_ttl(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpMulticastTtlResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4665cd378f39e1a, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#set_ip_multicast_loopback(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpMulticastLoopbackRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x20c55c11f00943ea,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#get_ip_multicast_loopback(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpMulticastLoopbackResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x3b6b26ff558298f2, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
    pub fn r#add_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (membership,),
                    0x76bc7df115a3b4d0,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
    pub fn r#drop_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (membership,),
                    0x2888f3099188d03,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#set_ip_transparent(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x1ae532b0c066e3a0,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#get_ip_transparent(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpTransparentResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x51d43695962ebfb5, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#set_ip_receive_original_destination_address(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x4722b4ce52f7840,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#get_ip_receive_original_destination_address(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x2a0e7dc5d6bfdfe9, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
    pub fn r#add_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (membership,),
                    0x7c94727acb4ea4b3,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
    pub fn r#drop_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketDropIpv6MembershipRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (membership,),
            0x42104c70ccaba304,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#set_ipv6_multicast_interface(
        &self,
        mut value: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x135f76db3774ab3b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#get_ipv6_multicast_interface(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x1f26fcdd348f1882, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#set_ipv6_unicast_hops(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6UnicastHopsRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x157d51e98f462859,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#get_ipv6_unicast_hops(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6UnicastHopsResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x21f4641cad8bd8d2, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#set_ipv6_receive_hop_limit(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x5c24808ed2e84a1e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#get_ipv6_receive_hop_limit(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x341e06689885b4c0, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#set_ipv6_multicast_hops(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6MulticastHopsRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x25b9cd4d181f82c1,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#get_ipv6_multicast_hops(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6MulticastHopsResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x52916948a365012a, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#set_ipv6_multicast_loopback(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x55701c409ff41b40,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#get_ipv6_multicast_loopback(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4415b701fde319c3, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#set_ipv6_only(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x4873f1364758cbba,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#get_ipv6_only(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6OnlyResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4aa3340a1a26b89c, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#set_ipv6_receive_traffic_class(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x58f07c8788d099a0,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#get_ipv6_receive_traffic_class(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x2e334df1da553ffa, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
    pub fn r#set_ipv6_traffic_class(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6TrafficClassRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x6af077800c5a0b4f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
    pub fn r#get_ipv6_traffic_class(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6TrafficClassResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x6baf6eed8fc2f04, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#set_ipv6_receive_packet_info(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x19259775b1a92768,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#get_ipv6_receive_packet_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x7acd4a2775baec75, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
    pub fn r#get_original_destination(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetOriginalDestinationResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x38bf28f0dafdbac0, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Retrieves creation information from the socket.
    ///
    /// - response `domain` the socket's associated domain.
    /// - response `proto` the socket's associated protocol.
    pub fn r#get_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseDatagramSocketGetInfoResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseDatagramSocketGetInfoResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x48aa0a1f6a32d2ed, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| (x.domain, x.proto)))
    }
}

#[cfg(target_os = "fuchsia")]
impl From<BaseDatagramSocketSynchronousProxy> for zx::Handle {
    fn from(value: BaseDatagramSocketSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for BaseDatagramSocketSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for BaseDatagramSocketSynchronousProxy {
    type Protocol = BaseDatagramSocketMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<BaseDatagramSocketMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct BaseDatagramSocketProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for BaseDatagramSocketProxy {
    type Protocol = BaseDatagramSocketMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl BaseDatagramSocketProxy {
    /// Create a new Proxy for fuchsia.posix.socket/BaseDatagramSocket.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <BaseDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> BaseDatagramSocketEventStream {
        BaseDatagramSocketEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#clone(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        BaseDatagramSocketProxyInterface::r#clone(self, request)
    }

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#close(self)
    }

    pub fn r#query(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        BaseDatagramSocketProxyInterface::r#query(self)
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#set_reuse_address(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_reuse_address(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#get_reuse_address(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_reuse_address(self)
    }

    /// Get `SOL_SOCKET` -> `SO_ERROR`.
    /// Returns the last error if there is an error set on the socket.
    pub fn r#get_error(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetErrorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_error(self)
    }

    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#set_broadcast(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_broadcast(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#get_broadcast(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_broadcast(self)
    }

    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#set_send_buffer(
        &self,
        mut value_bytes: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_send_buffer(self, value_bytes)
    }

    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#get_send_buffer(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_send_buffer(self)
    }

    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#set_receive_buffer(
        &self,
        mut value_bytes: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_receive_buffer(self, value_bytes)
    }

    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#get_receive_buffer(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_receive_buffer(self)
    }

    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#set_keep_alive(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_keep_alive(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#get_keep_alive(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_keep_alive(self)
    }

    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#set_out_of_band_inline(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_out_of_band_inline(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#get_out_of_band_inline(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_out_of_band_inline(self)
    }

    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#set_no_check(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_no_check(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#get_no_check(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_no_check(self)
    }

    /// Set `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#set_linger(
        &self,
        mut linger: bool,
        mut length_secs: u32,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_linger(self, linger, length_secs)
    }

    /// Get `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#get_linger(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_linger(self)
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#set_reuse_port(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_reuse_port(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#get_reuse_port(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_reuse_port(self)
    }

    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
    pub fn r#get_accept_conn(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetAcceptConnResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_accept_conn(self)
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#set_bind_to_device(
        &self,
        mut value: &str,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_bind_to_device(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#get_bind_to_device(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_bind_to_device(self)
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    /// If `value` is 0, this clears the bound interface.
    pub fn r#set_bind_to_interface_index(
        &self,
        mut value: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_bind_to_interface_index(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    pub fn r#get_bind_to_interface_index(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_bind_to_interface_index(self)
    }

    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#set_timestamp(
        &self,
        mut value: TimestampOption,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_timestamp(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#get_timestamp(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_timestamp(self)
    }

    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be set independently in each domain.
    pub fn r#set_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        mut mark: &OptionalUint32,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_mark(self, domain, mark)
    }

    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be retrieved independently in each domain.
    pub fn r#get_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_mark(self, domain)
    }

    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
    pub fn r#get_cookie(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetCookieResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_cookie(self)
    }

    /// Sets the local address used for the socket.
    pub fn r#bind(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketBindResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#bind(self, addr)
    }

    /// Initiates a connection to a remote address.
    pub fn r#connect(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#connect(self, addr)
    }

    /// Clears connection information from this socket.
    pub fn r#disconnect(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketDisconnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#disconnect(self)
    }

    /// Retrieves the local socket address.
    pub fn r#get_sock_name(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetSockNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_sock_name(self)
    }

    /// Retrieves the remote socket address.
    pub fn r#get_peer_name(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetPeerNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_peer_name(self)
    }

    /// Shuts down part of the socket.
    pub fn r#shutdown(
        &self,
        mut mode: ShutdownMode,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketShutdownResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#shutdown(self, mode)
    }

    /// Set `SOL_IP` -> `IP_TOS`.
    pub fn r#set_ip_type_of_service(
        &self,
        mut value: u8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ip_type_of_service(self, value)
    }

    /// Get `SOL_IP` -> `IP_TOS`.
    pub fn r#get_ip_type_of_service(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ip_type_of_service(self)
    }

    /// Set `SOL_IP` -> `IP_TTL`.
    pub fn r#set_ip_ttl(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ip_ttl(self, value)
    }

    /// Get `SOL_IP` -> `IP_TTL`.
    pub fn r#get_ip_ttl(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ip_ttl(self)
    }

    /// Set `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#set_ip_packet_info(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ip_packet_info(self, value)
    }

    /// Get `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#get_ip_packet_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ip_packet_info(self)
    }

    /// Set `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#set_ip_receive_type_of_service(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ip_receive_type_of_service(self, value)
    }

    /// Get `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#get_ip_receive_type_of_service(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ip_receive_type_of_service(self)
    }

    /// Set `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#set_ip_receive_ttl(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ip_receive_ttl(self, value)
    }

    /// Get `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#get_ip_receive_ttl(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ip_receive_ttl(self)
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#set_ip_multicast_interface(
        &self,
        mut iface: u64,
        mut address: &fidl_fuchsia_net::Ipv4Address,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ip_multicast_interface(self, iface, address)
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#get_ip_multicast_interface(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ip_multicast_interface(self)
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#set_ip_multicast_ttl(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ip_multicast_ttl(self, value)
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#get_ip_multicast_ttl(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ip_multicast_ttl(self)
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#set_ip_multicast_loopback(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ip_multicast_loopback(self, value)
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#get_ip_multicast_loopback(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ip_multicast_loopback(self)
    }

    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
    pub fn r#add_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#add_ip_membership(self, membership)
    }

    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
    pub fn r#drop_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#drop_ip_membership(self, membership)
    }

    /// Set `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#set_ip_transparent(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ip_transparent(self, value)
    }

    /// Get `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#get_ip_transparent(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ip_transparent(self)
    }

    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#set_ip_receive_original_destination_address(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ip_receive_original_destination_address(self, value)
    }

    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#get_ip_receive_original_destination_address(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ip_receive_original_destination_address(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
    pub fn r#add_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#add_ipv6_membership(self, membership)
    }

    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
    pub fn r#drop_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#drop_ipv6_membership(self, membership)
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#set_ipv6_multicast_interface(
        &self,
        mut value: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ipv6_multicast_interface(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#get_ipv6_multicast_interface(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ipv6_multicast_interface(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#set_ipv6_unicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ipv6_unicast_hops(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#get_ipv6_unicast_hops(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ipv6_unicast_hops(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#set_ipv6_receive_hop_limit(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ipv6_receive_hop_limit(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#get_ipv6_receive_hop_limit(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ipv6_receive_hop_limit(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#set_ipv6_multicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ipv6_multicast_hops(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#get_ipv6_multicast_hops(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ipv6_multicast_hops(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#set_ipv6_multicast_loopback(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ipv6_multicast_loopback(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#get_ipv6_multicast_loopback(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ipv6_multicast_loopback(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#set_ipv6_only(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ipv6_only(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#get_ipv6_only(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ipv6_only(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#set_ipv6_receive_traffic_class(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ipv6_receive_traffic_class(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#get_ipv6_receive_traffic_class(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ipv6_receive_traffic_class(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
    pub fn r#set_ipv6_traffic_class(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ipv6_traffic_class(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
    pub fn r#get_ipv6_traffic_class(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ipv6_traffic_class(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#set_ipv6_receive_packet_info(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#set_ipv6_receive_packet_info(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#get_ipv6_receive_packet_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_ipv6_receive_packet_info(self)
    }

    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
    pub fn r#get_original_destination(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetOriginalDestinationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_original_destination(self)
    }

    /// Retrieves creation information from the socket.
    ///
    /// - response `domain` the socket's associated domain.
    /// - response `proto` the socket's associated protocol.
    pub fn r#get_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseDatagramSocketGetInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseDatagramSocketProxyInterface::r#get_info(self)
    }
}

impl BaseDatagramSocketProxyInterface for BaseDatagramSocketProxy {
    fn r#clone(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type CloseResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#close(&self) -> Self::CloseResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5ac5d459ad7f657e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_unknown::CloseableCloseResult,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryResponseFut =
        fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#query(&self) -> Self::QueryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<u8>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl_fuchsia_unknown::QueryableQueryResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2658edee9decfc06,
            >(_buf?)?;
            Ok(_response.protocol)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1fd74ee8b9a4a876,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetReuseAddressRequest,
            BaseSocketSetReuseAddressResult,
        >(
            (value,),
            0x1fd74ee8b9a4a876,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetReuseAddressResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x67b7206b8d1bc0a5,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReuseAddressResult>(
                (),
                0x67b7206b8d1bc0a5,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetErrorResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetErrorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_error(&self) -> Self::GetErrorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5aad39b33e5f6ebb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetErrorResult>(
            (),
            0x5aad39b33e5f6ebb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6023e081ce3cd947,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetBroadcastRequest, BaseSocketSetBroadcastResult>(
                (value,),
                0x6023e081ce3cd947,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetBroadcastResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x68796fc556f9780d,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBroadcastResult>(
                (),
                0x68796fc556f9780d,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x756eac32d73a7a70,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetSendBufferRequest, BaseSocketSetSendBufferResult>(
                (value_bytes,),
                0x756eac32d73a7a70,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetSendBufferResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x78a52fd9c7b2410b,
            >(_buf?)?;
            Ok(_response.map(|x| x.value_bytes))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetSendBufferResult>(
                (),
                0x78a52fd9c7b2410b,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6b0cf2f1919c7001,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetReceiveBufferRequest,
            BaseSocketSetReceiveBufferResult,
        >(
            (value_bytes,),
            0x6b0cf2f1919c7001,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetReceiveBufferResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x14c1a4b64f709e5c,
            >(_buf?)?;
            Ok(_response.map(|x| x.value_bytes))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseSocketGetReceiveBufferResult,
        >(
            (),
            0x14c1a4b64f709e5c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x572df8f0b920d2c7,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetKeepAliveRequest, BaseSocketSetKeepAliveResult>(
                (value,),
                0x572df8f0b920d2c7,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetKeepAliveResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2dd29d3215f2c9d2,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetKeepAliveResult>(
                (),
                0x2dd29d3215f2c9d2,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3ecb49968bee439,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetOutOfBandInlineRequest,
            BaseSocketSetOutOfBandInlineResult,
        >(
            (value,),
            0x3ecb49968bee439,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetOutOfBandInlineResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x348c1ab3aeca1745,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseSocketGetOutOfBandInlineResult,
        >(
            (),
            0x348c1ab3aeca1745,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6bbf00c53a4c78c2,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetNoCheckRequest, BaseSocketSetNoCheckResult>(
                (value,),
                0x6bbf00c53a4c78c2,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetNoCheckResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2cd4249286417694,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetNoCheckResult>(
                (),
                0x2cd4249286417694,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetLingerResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x45386351246e998e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<BaseSocketSetLingerRequest, BaseSocketSetLingerResult>(
            (linger, length_secs),
            0x45386351246e998e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetLingerResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_linger(&self) -> Self::GetLingerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetLingerResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x48eb20fc5ccb0e45,
            >(_buf?)?;
            Ok(_response.map(|x| (x.linger, x.length_secs)))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetLingerResult>(
                (),
                0x48eb20fc5ccb0e45,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetReusePortResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x24dd3e5cb36d9ccb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetReusePortRequest, BaseSocketSetReusePortResult>(
                (value,),
                0x24dd3e5cb36d9ccb,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetReusePortResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetReusePortResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7a112c1ab54ff828,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReusePortResult>(
                (),
                0x7a112c1ab54ff828,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetAcceptConnResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetAcceptConnResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x67ce6db6c2ec8966,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetAcceptConnResult>(
                (),
                0x67ce6db6c2ec8966,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2118b483f28aafc4,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetBindToDeviceRequest,
            BaseSocketSetBindToDeviceResult,
        >(
            (value,),
            0x2118b483f28aafc4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetBindToDeviceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ab1fbf0ef7906c8,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBindToDeviceResult>(
                (),
                0x1ab1fbf0ef7906c8,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_bind_to_interface_index(
        &self,
        mut value: u64,
    ) -> Self::SetBindToInterfaceIndexResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6e387a0def00821,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetBindToInterfaceIndexRequest,
            BaseSocketSetBindToInterfaceIndexResult,
        >(
            (value,),
            0x6e387a0def00821,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetBindToInterfaceIndexResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x59c31dd3e3078295,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseSocketGetBindToInterfaceIndexResult,
        >(
            (),
            0x59c31dd3e3078295,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetTimestampResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_timestamp(&self, mut value: TimestampOption) -> Self::SetTimestampResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x285d6516c263d839,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetTimestampRequest, BaseSocketSetTimestampResult>(
                (value,),
                0x285d6516c263d839,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetTimestampResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetTimestampResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x49f2fffbbcc2bd27,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetTimestampResult>(
                (),
                0x49f2fffbbcc2bd27,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetMarkResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        mut mark: &OptionalUint32,
    ) -> Self::SetMarkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6ead6de09f653236,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<BaseSocketSetMarkRequest, BaseSocketSetMarkResult>(
            (domain, mark),
            0x6ead6de09f653236,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetMarkResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x57a2752c61d93d47,
            >(_buf?)?;
            Ok(_response.map(|x| x.mark))
        }
        self.client.send_query_and_decode::<BaseSocketGetMarkRequest, BaseSocketGetMarkResult>(
            (domain,),
            0x57a2752c61d93d47,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetCookieResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetCookieResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_cookie(&self) -> Self::GetCookieResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetCookieResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetCookieResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2c2f47fd8f924e52,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetCookieResult>(
                (),
                0x2c2f47fd8f924e52,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type BindResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketBindResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#bind(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4bc6400ae92125d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseNetworkSocketBindRequest, BaseNetworkSocketBindResult>(
                (addr,),
                0x4bc6400ae92125d,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ConnectResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5f05f19bfdd38871,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketConnectRequest,
            BaseNetworkSocketConnectResult,
        >(
            (addr,),
            0x5f05f19bfdd38871,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DisconnectResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketDisconnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#disconnect(&self) -> Self::DisconnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x74e63b91f7b29b2,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketDisconnectResult,
        >(
            (),
            0x74e63b91f7b29b2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetSockNameResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetSockNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetSockNameResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x475f23f84a1a4f85,
            >(_buf?)?;
            Ok(_response.map(|x| x.addr))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetSockNameResult,
        >(
            (),
            0x475f23f84a1a4f85,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetPeerNameResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetPeerNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetPeerNameResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ffecf4bd5b6432e,
            >(_buf?)?;
            Ok(_response.map(|x| x.addr))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetPeerNameResult,
        >(
            (),
            0x1ffecf4bd5b6432e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ShutdownResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketShutdownResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#shutdown(&self, mut mode: ShutdownMode) -> Self::ShutdownResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x247f38b6db68c336,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketShutdownRequest,
            BaseNetworkSocketShutdownResult,
        >(
            (mode,),
            0x247f38b6db68c336,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_type_of_service(&self, mut value: u8) -> Self::SetIpTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x995c600475b6d46,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpTypeOfServiceRequest,
            BaseNetworkSocketSetIpTypeOfServiceResult,
        >(
            (value,),
            0x995c600475b6d46,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpTypeOfServiceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3814a04259f75fcb,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpTypeOfServiceResult,
        >(
            (),
            0x3814a04259f75fcb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_ttl(&self, mut value: &OptionalUint8) -> Self::SetIpTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x29e2424b433ae1ef,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpTtlRequest,
            BaseNetworkSocketSetIpTtlResult,
        >(
            (value,),
            0x29e2424b433ae1ef,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpTtlResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x47e47fa1f24da471,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseNetworkSocketGetIpTtlResult>(
                (),
                0x47e47fa1f24da471,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_packet_info(&self, mut value: bool) -> Self::SetIpPacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x392d16bee20c0e16,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpPacketInfoRequest,
            BaseNetworkSocketSetIpPacketInfoResult,
        >(
            (value,),
            0x392d16bee20c0e16,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpPacketInfoResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x54b505f242280740,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpPacketInfoResult,
        >(
            (),
            0x54b505f242280740,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_receive_type_of_service(
        &self,
        mut value: bool,
    ) -> Self::SetIpReceiveTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6c4f6714995f84ef,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
            BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
        >(
            (value,),
            0x6c4f6714995f84ef,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4158ba7dc2795960,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
        >(
            (),
            0x4158ba7dc2795960,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_receive_ttl(&self, mut value: bool) -> Self::SetIpReceiveTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x46f15be0ce0ab82b,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpReceiveTtlRequest,
            BaseNetworkSocketSetIpReceiveTtlResult,
        >(
            (value,),
            0x46f15be0ce0ab82b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpReceiveTtlResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x678ddd5a5dfa2eb5,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpReceiveTtlResult,
        >(
            (),
            0x678ddd5a5dfa2eb5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_multicast_interface(
        &self,
        mut iface: u64,
        mut address: &fidl_fuchsia_net::Ipv4Address,
    ) -> Self::SetIpMulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x752fbfa9b12befe,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpMulticastInterfaceRequest,
            BaseNetworkSocketSetIpMulticastInterfaceResult,
        >(
            (iface, address,),
            0x752fbfa9b12befe,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpMulticastInterfaceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x320bd14c4df046c4,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpMulticastInterfaceResult,
        >(
            (),
            0x320bd14c4df046c4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_multicast_ttl(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpMulticastTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x63134d53772916a1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpMulticastTtlRequest,
            BaseNetworkSocketSetIpMulticastTtlResult,
        >(
            (value,),
            0x63134d53772916a1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpMulticastTtlResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4665cd378f39e1a,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpMulticastTtlResult,
        >(
            (),
            0x4665cd378f39e1a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_multicast_loopback(
        &self,
        mut value: bool,
    ) -> Self::SetIpMulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x20c55c11f00943ea,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpMulticastLoopbackRequest,
            BaseNetworkSocketSetIpMulticastLoopbackResult,
        >(
            (value,),
            0x20c55c11f00943ea,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpMulticastLoopbackResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3b6b26ff558298f2,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpMulticastLoopbackResult,
        >(
            (),
            0x3b6b26ff558298f2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddIpMembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> Self::AddIpMembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x76bc7df115a3b4d0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketAddIpMembershipRequest,
            BaseNetworkSocketAddIpMembershipResult,
        >(
            (membership,),
            0x76bc7df115a3b4d0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DropIpMembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#drop_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> Self::DropIpMembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2888f3099188d03,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketDropIpMembershipRequest,
            BaseNetworkSocketDropIpMembershipResult,
        >(
            (membership,),
            0x2888f3099188d03,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpTransparentResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_transparent(&self, mut value: bool) -> Self::SetIpTransparentResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ae532b0c066e3a0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpTransparentRequest,
            BaseNetworkSocketSetIpTransparentResult,
        >(
            (value,),
            0x1ae532b0c066e3a0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpTransparentResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpTransparentResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x51d43695962ebfb5,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpTransparentResult,
        >(
            (),
            0x51d43695962ebfb5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_receive_original_destination_address(
        &self,
        mut value: bool,
    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4722b4ce52f7840,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
        >(
            (value,),
            0x4722b4ce52f7840,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_receive_original_destination_address(
        &self,
    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2a0e7dc5d6bfdfe9,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
        >(
            (),
            0x2a0e7dc5d6bfdfe9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> Self::AddIpv6MembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7c94727acb4ea4b3,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketAddIpv6MembershipRequest,
            BaseNetworkSocketAddIpv6MembershipResult,
        >(
            (membership,),
            0x7c94727acb4ea4b3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DropIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#drop_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> Self::DropIpv6MembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x42104c70ccaba304,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketDropIpv6MembershipRequest,
            BaseNetworkSocketDropIpv6MembershipResult,
        >(
            (membership,),
            0x42104c70ccaba304,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_multicast_interface(
        &self,
        mut value: u64,
    ) -> Self::SetIpv6MulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x135f76db3774ab3b,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
            BaseNetworkSocketSetIpv6MulticastInterfaceResult,
        >(
            (value,),
            0x135f76db3774ab3b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1f26fcdd348f1882,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6MulticastInterfaceResult,
        >(
            (),
            0x1f26fcdd348f1882,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_unicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpv6UnicastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x157d51e98f462859,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6UnicastHopsRequest,
            BaseNetworkSocketSetIpv6UnicastHopsResult,
        >(
            (value,),
            0x157d51e98f462859,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6UnicastHopsResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x21f4641cad8bd8d2,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6UnicastHopsResult,
        >(
            (),
            0x21f4641cad8bd8d2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_receive_hop_limit(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6ReceiveHopLimitResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5c24808ed2e84a1e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
            BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
        >(
            (value,),
            0x5c24808ed2e84a1e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x341e06689885b4c0,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
        >(
            (),
            0x341e06689885b4c0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_multicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpv6MulticastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x25b9cd4d181f82c1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6MulticastHopsRequest,
            BaseNetworkSocketSetIpv6MulticastHopsResult,
        >(
            (value,),
            0x25b9cd4d181f82c1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6MulticastHopsResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x52916948a365012a,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6MulticastHopsResult,
        >(
            (),
            0x52916948a365012a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_multicast_loopback(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6MulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x55701c409ff41b40,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
            BaseNetworkSocketSetIpv6MulticastLoopbackResult,
        >(
            (value,),
            0x55701c409ff41b40,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4415b701fde319c3,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6MulticastLoopbackResult,
        >(
            (),
            0x4415b701fde319c3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_only(&self, mut value: bool) -> Self::SetIpv6OnlyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4873f1364758cbba,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6OnlyRequest,
            BaseNetworkSocketSetIpv6OnlyResult,
        >(
            (value,),
            0x4873f1364758cbba,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6OnlyResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4aa3340a1a26b89c,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6OnlyResult,
        >(
            (),
            0x4aa3340a1a26b89c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_receive_traffic_class(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x58f07c8788d099a0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
            BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
        >(
            (value,),
            0x58f07c8788d099a0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2e334df1da553ffa,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
        >(
            (),
            0x2e334df1da553ffa,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_traffic_class(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpv6TrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6af077800c5a0b4f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6TrafficClassRequest,
            BaseNetworkSocketSetIpv6TrafficClassResult,
        >(
            (value,),
            0x6af077800c5a0b4f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6TrafficClassResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6baf6eed8fc2f04,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6TrafficClassResult,
        >(
            (),
            0x6baf6eed8fc2f04,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_receive_packet_info(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6ReceivePacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x19259775b1a92768,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
            BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
        >(
            (value,),
            0x19259775b1a92768,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7acd4a2775baec75,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
        >(
            (),
            0x7acd4a2775baec75,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetOriginalDestinationResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetOriginalDestinationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetOriginalDestinationResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x38bf28f0dafdbac0,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetOriginalDestinationResult,
        >(
            (),
            0x38bf28f0dafdbac0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetInfoResponseFut = fidl::client::QueryResponseFut<
        BaseDatagramSocketGetInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_info(&self) -> Self::GetInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseDatagramSocketGetInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseDatagramSocketGetInfoResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x48aa0a1f6a32d2ed,
            >(_buf?)?;
            Ok(_response.map(|x| (x.domain, x.proto)))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseDatagramSocketGetInfoResult>(
                (),
                0x48aa0a1f6a32d2ed,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

pub struct BaseDatagramSocketEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for BaseDatagramSocketEventStream {}

impl futures::stream::FusedStream for BaseDatagramSocketEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for BaseDatagramSocketEventStream {
    type Item = Result<BaseDatagramSocketEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(BaseDatagramSocketEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum BaseDatagramSocketEvent {}

impl BaseDatagramSocketEvent {
    /// Decodes a message buffer as a [`BaseDatagramSocketEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<BaseDatagramSocketEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <BaseDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.posix.socket/BaseDatagramSocket.
pub struct BaseDatagramSocketRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for BaseDatagramSocketRequestStream {}

impl futures::stream::FusedStream for BaseDatagramSocketRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for BaseDatagramSocketRequestStream {
    type Protocol = BaseDatagramSocketMarker;
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        BaseDatagramSocketControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for BaseDatagramSocketRequestStream {
    type Item = Result<BaseDatagramSocketRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled BaseDatagramSocketRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                0x20d8a7aba2168a79 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(fidl_fuchsia_unknown::CloneableCloneRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::Clone {request: req.request,

                        control_handle,
                    })
                }
                0x5ac5d459ad7f657e => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::Close {
                        responder: BaseDatagramSocketCloseResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2658edee9decfc06 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::Query {
                        responder: BaseDatagramSocketQueryResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1fd74ee8b9a4a876 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetReuseAddressRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetReuseAddress {value: req.value,

                        responder: BaseDatagramSocketSetReuseAddressResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x67b7206b8d1bc0a5 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetReuseAddress {
                        responder: BaseDatagramSocketGetReuseAddressResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x5aad39b33e5f6ebb => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetError {
                        responder: BaseDatagramSocketGetErrorResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6023e081ce3cd947 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetBroadcastRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetBroadcast {value: req.value,

                        responder: BaseDatagramSocketSetBroadcastResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x68796fc556f9780d => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetBroadcast {
                        responder: BaseDatagramSocketGetBroadcastResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x756eac32d73a7a70 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetSendBufferRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetSendBuffer {value_bytes: req.value_bytes,

                        responder: BaseDatagramSocketSetSendBufferResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x78a52fd9c7b2410b => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetSendBuffer {
                        responder: BaseDatagramSocketGetSendBufferResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6b0cf2f1919c7001 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetReceiveBufferRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetReceiveBuffer {value_bytes: req.value_bytes,

                        responder: BaseDatagramSocketSetReceiveBufferResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x14c1a4b64f709e5c => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetReceiveBuffer {
                        responder: BaseDatagramSocketGetReceiveBufferResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x572df8f0b920d2c7 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetKeepAliveRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetKeepAlive {value: req.value,

                        responder: BaseDatagramSocketSetKeepAliveResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2dd29d3215f2c9d2 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetKeepAlive {
                        responder: BaseDatagramSocketGetKeepAliveResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x3ecb49968bee439 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetOutOfBandInlineRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetOutOfBandInline {value: req.value,

                        responder: BaseDatagramSocketSetOutOfBandInlineResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x348c1ab3aeca1745 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetOutOfBandInline {
                        responder: BaseDatagramSocketGetOutOfBandInlineResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6bbf00c53a4c78c2 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetNoCheckRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetNoCheck {value: req.value,

                        responder: BaseDatagramSocketSetNoCheckResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2cd4249286417694 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetNoCheck {
                        responder: BaseDatagramSocketGetNoCheckResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x45386351246e998e => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetLingerRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetLinger {linger: req.linger,
length_secs: req.length_secs,

                        responder: BaseDatagramSocketSetLingerResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x48eb20fc5ccb0e45 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetLinger {
                        responder: BaseDatagramSocketGetLingerResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x24dd3e5cb36d9ccb => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetReusePortRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetReusePort {value: req.value,

                        responder: BaseDatagramSocketSetReusePortResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x7a112c1ab54ff828 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetReusePort {
                        responder: BaseDatagramSocketGetReusePortResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x67ce6db6c2ec8966 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetAcceptConn {
                        responder: BaseDatagramSocketGetAcceptConnResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2118b483f28aafc4 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetBindToDeviceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetBindToDevice {value: req.value,

                        responder: BaseDatagramSocketSetBindToDeviceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1ab1fbf0ef7906c8 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetBindToDevice {
                        responder: BaseDatagramSocketGetBindToDeviceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6e387a0def00821 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetBindToInterfaceIndex {value: req.value,

                        responder: BaseDatagramSocketSetBindToInterfaceIndexResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x59c31dd3e3078295 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetBindToInterfaceIndex {
                        responder: BaseDatagramSocketGetBindToInterfaceIndexResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x285d6516c263d839 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetTimestampRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetTimestamp {value: req.value,

                        responder: BaseDatagramSocketSetTimestampResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x49f2fffbbcc2bd27 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetTimestamp {
                        responder: BaseDatagramSocketGetTimestampResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6ead6de09f653236 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetMarkRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetMark {domain: req.domain,
mark: req.mark,

                        responder: BaseDatagramSocketSetMarkResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x57a2752c61d93d47 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketGetMarkRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetMark {domain: req.domain,

                        responder: BaseDatagramSocketGetMarkResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2c2f47fd8f924e52 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetCookie {
                        responder: BaseDatagramSocketGetCookieResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4bc6400ae92125d => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketBindRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketBindRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::Bind {addr: req.addr,

                        responder: BaseDatagramSocketBindResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x5f05f19bfdd38871 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::Connect {addr: req.addr,

                        responder: BaseDatagramSocketConnectResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x74e63b91f7b29b2 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::Disconnect {
                        responder: BaseDatagramSocketDisconnectResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x475f23f84a1a4f85 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetSockName {
                        responder: BaseDatagramSocketGetSockNameResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1ffecf4bd5b6432e => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetPeerName {
                        responder: BaseDatagramSocketGetPeerNameResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x247f38b6db68c336 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketShutdownRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketShutdownRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::Shutdown {mode: req.mode,

                        responder: BaseDatagramSocketShutdownResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x995c600475b6d46 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpTypeOfServiceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpTypeOfService {value: req.value,

                        responder: BaseDatagramSocketSetIpTypeOfServiceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x3814a04259f75fcb => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpTypeOfService {
                        responder: BaseDatagramSocketGetIpTypeOfServiceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x29e2424b433ae1ef => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpTtlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTtlRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpTtl {value: req.value,

                        responder: BaseDatagramSocketSetIpTtlResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x47e47fa1f24da471 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpTtl {
                        responder: BaseDatagramSocketGetIpTtlResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x392d16bee20c0e16 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpPacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpPacketInfo {value: req.value,

                        responder: BaseDatagramSocketSetIpPacketInfoResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x54b505f242280740 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpPacketInfo {
                        responder: BaseDatagramSocketGetIpPacketInfoResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6c4f6714995f84ef => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpReceiveTypeOfServiceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpReceiveTypeOfService {value: req.value,

                        responder: BaseDatagramSocketSetIpReceiveTypeOfServiceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4158ba7dc2795960 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpReceiveTypeOfService {
                        responder: BaseDatagramSocketGetIpReceiveTypeOfServiceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x46f15be0ce0ab82b => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTtlRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpReceiveTtl {value: req.value,

                        responder: BaseDatagramSocketSetIpReceiveTtlResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x678ddd5a5dfa2eb5 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpReceiveTtl {
                        responder: BaseDatagramSocketGetIpReceiveTtlResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x752fbfa9b12befe => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpMulticastInterfaceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpMulticastInterface {iface: req.iface,
address: req.address,

                        responder: BaseDatagramSocketSetIpMulticastInterfaceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x320bd14c4df046c4 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpMulticastInterface {
                        responder: BaseDatagramSocketGetIpMulticastInterfaceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x63134d53772916a1 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastTtlRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpMulticastTtl {value: req.value,

                        responder: BaseDatagramSocketSetIpMulticastTtlResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4665cd378f39e1a => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpMulticastTtl {
                        responder: BaseDatagramSocketGetIpMulticastTtlResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x20c55c11f00943ea => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpMulticastLoopbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpMulticastLoopback {value: req.value,

                        responder: BaseDatagramSocketSetIpMulticastLoopbackResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x3b6b26ff558298f2 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpMulticastLoopback {
                        responder: BaseDatagramSocketGetIpMulticastLoopbackResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x76bc7df115a3b4d0 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::AddIpMembership {membership: req.membership,

                        responder: BaseDatagramSocketAddIpMembershipResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2888f3099188d03 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::DropIpMembership {membership: req.membership,

                        responder: BaseDatagramSocketDropIpMembershipResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1ae532b0c066e3a0 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTransparentRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpTransparent {value: req.value,

                        responder: BaseDatagramSocketSetIpTransparentResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x51d43695962ebfb5 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpTransparent {
                        responder: BaseDatagramSocketGetIpTransparentResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4722b4ce52f7840 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpReceiveOriginalDestinationAddress {value: req.value,

                        responder: BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2a0e7dc5d6bfdfe9 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpReceiveOriginalDestinationAddress {
                        responder: BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x7c94727acb4ea4b3 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::AddIpv6Membership {membership: req.membership,

                        responder: BaseDatagramSocketAddIpv6MembershipResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x42104c70ccaba304 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketDropIpv6MembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::DropIpv6Membership {membership: req.membership,

                        responder: BaseDatagramSocketDropIpv6MembershipResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x135f76db3774ab3b => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6MulticastInterfaceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpv6MulticastInterface {value: req.value,

                        responder: BaseDatagramSocketSetIpv6MulticastInterfaceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1f26fcdd348f1882 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpv6MulticastInterface {
                        responder: BaseDatagramSocketGetIpv6MulticastInterfaceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x157d51e98f462859 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6UnicastHopsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6UnicastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpv6UnicastHops {value: req.value,

                        responder: BaseDatagramSocketSetIpv6UnicastHopsResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x21f4641cad8bd8d2 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpv6UnicastHops {
                        responder: BaseDatagramSocketGetIpv6UnicastHopsResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x5c24808ed2e84a1e => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6ReceiveHopLimitRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveHopLimitRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpv6ReceiveHopLimit {value: req.value,

                        responder: BaseDatagramSocketSetIpv6ReceiveHopLimitResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x341e06689885b4c0 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpv6ReceiveHopLimit {
                        responder: BaseDatagramSocketGetIpv6ReceiveHopLimitResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x25b9cd4d181f82c1 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6MulticastHopsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpv6MulticastHops {value: req.value,

                        responder: BaseDatagramSocketSetIpv6MulticastHopsResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x52916948a365012a => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpv6MulticastHops {
                        responder: BaseDatagramSocketGetIpv6MulticastHopsResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x55701c409ff41b40 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6MulticastLoopbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpv6MulticastLoopback {value: req.value,

                        responder: BaseDatagramSocketSetIpv6MulticastLoopbackResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4415b701fde319c3 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpv6MulticastLoopback {
                        responder: BaseDatagramSocketGetIpv6MulticastLoopbackResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4873f1364758cbba => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6OnlyRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpv6Only {value: req.value,

                        responder: BaseDatagramSocketSetIpv6OnlyResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4aa3340a1a26b89c => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpv6Only {
                        responder: BaseDatagramSocketGetIpv6OnlyResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x58f07c8788d099a0 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpv6ReceiveTrafficClass {value: req.value,

                        responder: BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2e334df1da553ffa => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpv6ReceiveTrafficClass {
                        responder: BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6af077800c5a0b4f => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6TrafficClassRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6TrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpv6TrafficClass {value: req.value,

                        responder: BaseDatagramSocketSetIpv6TrafficClassResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6baf6eed8fc2f04 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpv6TrafficClass {
                        responder: BaseDatagramSocketGetIpv6TrafficClassResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x19259775b1a92768 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6ReceivePacketInfoRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceivePacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::SetIpv6ReceivePacketInfo {value: req.value,

                        responder: BaseDatagramSocketSetIpv6ReceivePacketInfoResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x7acd4a2775baec75 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetIpv6ReceivePacketInfo {
                        responder: BaseDatagramSocketGetIpv6ReceivePacketInfoResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x38bf28f0dafdbac0 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetOriginalDestination {
                        responder: BaseDatagramSocketGetOriginalDestinationResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x48aa0a1f6a32d2ed => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = BaseDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(BaseDatagramSocketRequest::GetInfo {
                        responder: BaseDatagramSocketGetInfoResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <BaseDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Base protocol shared by all datagram sockets.
///
/// Complete implementations of a datagram socket should compose this protocol.
#[derive(Debug)]
pub enum BaseDatagramSocketRequest {
    Clone {
        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
        control_handle: BaseDatagramSocketControlHandle,
    },
    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    Close {
        responder: BaseDatagramSocketCloseResponder,
    },
    Query {
        responder: BaseDatagramSocketQueryResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
    SetReuseAddress {
        value: bool,
        responder: BaseDatagramSocketSetReuseAddressResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
    GetReuseAddress {
        responder: BaseDatagramSocketGetReuseAddressResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_ERROR`.
    /// Returns the last error if there is an error set on the socket.
    GetError {
        responder: BaseDatagramSocketGetErrorResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
    SetBroadcast {
        value: bool,
        responder: BaseDatagramSocketSetBroadcastResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
    GetBroadcast {
        responder: BaseDatagramSocketGetBroadcastResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
    SetSendBuffer {
        value_bytes: u64,
        responder: BaseDatagramSocketSetSendBufferResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
    GetSendBuffer {
        responder: BaseDatagramSocketGetSendBufferResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
    SetReceiveBuffer {
        value_bytes: u64,
        responder: BaseDatagramSocketSetReceiveBufferResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
    GetReceiveBuffer {
        responder: BaseDatagramSocketGetReceiveBufferResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
    SetKeepAlive {
        value: bool,
        responder: BaseDatagramSocketSetKeepAliveResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
    GetKeepAlive {
        responder: BaseDatagramSocketGetKeepAliveResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
    SetOutOfBandInline {
        value: bool,
        responder: BaseDatagramSocketSetOutOfBandInlineResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
    GetOutOfBandInline {
        responder: BaseDatagramSocketGetOutOfBandInlineResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
    SetNoCheck {
        value: bool,
        responder: BaseDatagramSocketSetNoCheckResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
    GetNoCheck {
        responder: BaseDatagramSocketGetNoCheckResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_LINGER`.
    SetLinger {
        linger: bool,
        length_secs: u32,
        responder: BaseDatagramSocketSetLingerResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_LINGER`.
    GetLinger {
        responder: BaseDatagramSocketGetLingerResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
    SetReusePort {
        value: bool,
        responder: BaseDatagramSocketSetReusePortResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
    GetReusePort {
        responder: BaseDatagramSocketGetReusePortResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
    GetAcceptConn {
        responder: BaseDatagramSocketGetAcceptConnResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    SetBindToDevice {
        value: String,
        responder: BaseDatagramSocketSetBindToDeviceResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    GetBindToDevice {
        responder: BaseDatagramSocketGetBindToDeviceResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    /// If `value` is 0, this clears the bound interface.
    SetBindToInterfaceIndex {
        value: u64,
        responder: BaseDatagramSocketSetBindToInterfaceIndexResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    GetBindToInterfaceIndex {
        responder: BaseDatagramSocketGetBindToInterfaceIndexResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    SetTimestamp {
        value: TimestampOption,
        responder: BaseDatagramSocketSetTimestampResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    GetTimestamp {
        responder: BaseDatagramSocketGetTimestampResponder,
    },
    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be set independently in each domain.
    SetMark {
        domain: fidl_fuchsia_net::MarkDomain,
        mark: OptionalUint32,
        responder: BaseDatagramSocketSetMarkResponder,
    },
    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be retrieved independently in each domain.
    GetMark {
        domain: fidl_fuchsia_net::MarkDomain,
        responder: BaseDatagramSocketGetMarkResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
    GetCookie {
        responder: BaseDatagramSocketGetCookieResponder,
    },
    /// Sets the local address used for the socket.
    Bind {
        addr: fidl_fuchsia_net::SocketAddress,
        responder: BaseDatagramSocketBindResponder,
    },
    /// Initiates a connection to a remote address.
    Connect {
        addr: fidl_fuchsia_net::SocketAddress,
        responder: BaseDatagramSocketConnectResponder,
    },
    /// Clears connection information from this socket.
    Disconnect {
        responder: BaseDatagramSocketDisconnectResponder,
    },
    /// Retrieves the local socket address.
    GetSockName {
        responder: BaseDatagramSocketGetSockNameResponder,
    },
    /// Retrieves the remote socket address.
    GetPeerName {
        responder: BaseDatagramSocketGetPeerNameResponder,
    },
    /// Shuts down part of the socket.
    Shutdown {
        mode: ShutdownMode,
        responder: BaseDatagramSocketShutdownResponder,
    },
    /// Set `SOL_IP` -> `IP_TOS`.
    SetIpTypeOfService {
        value: u8,
        responder: BaseDatagramSocketSetIpTypeOfServiceResponder,
    },
    /// Get `SOL_IP` -> `IP_TOS`.
    GetIpTypeOfService {
        responder: BaseDatagramSocketGetIpTypeOfServiceResponder,
    },
    /// Set `SOL_IP` -> `IP_TTL`.
    SetIpTtl {
        value: OptionalUint8,
        responder: BaseDatagramSocketSetIpTtlResponder,
    },
    /// Get `SOL_IP` -> `IP_TTL`.
    GetIpTtl {
        responder: BaseDatagramSocketGetIpTtlResponder,
    },
    /// Set `SOL_IP` -> `IP_PKTINFO`.
    SetIpPacketInfo {
        value: bool,
        responder: BaseDatagramSocketSetIpPacketInfoResponder,
    },
    /// Get `SOL_IP` -> `IP_PKTINFO`.
    GetIpPacketInfo {
        responder: BaseDatagramSocketGetIpPacketInfoResponder,
    },
    /// Set `SOL_IP` -> `IP_RECVTOS`.
    SetIpReceiveTypeOfService {
        value: bool,
        responder: BaseDatagramSocketSetIpReceiveTypeOfServiceResponder,
    },
    /// Get `SOL_IP` -> `IP_RECVTOS`.
    GetIpReceiveTypeOfService {
        responder: BaseDatagramSocketGetIpReceiveTypeOfServiceResponder,
    },
    /// Set `SOL_IP` -> `IP_RECVTTL`.
    SetIpReceiveTtl {
        value: bool,
        responder: BaseDatagramSocketSetIpReceiveTtlResponder,
    },
    /// Get `SOL_IP` -> `IP_RECVTTL`.
    GetIpReceiveTtl {
        responder: BaseDatagramSocketGetIpReceiveTtlResponder,
    },
    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
    SetIpMulticastInterface {
        iface: u64,
        address: fidl_fuchsia_net::Ipv4Address,
        responder: BaseDatagramSocketSetIpMulticastInterfaceResponder,
    },
    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
    GetIpMulticastInterface {
        responder: BaseDatagramSocketGetIpMulticastInterfaceResponder,
    },
    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
    SetIpMulticastTtl {
        value: OptionalUint8,
        responder: BaseDatagramSocketSetIpMulticastTtlResponder,
    },
    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
    GetIpMulticastTtl {
        responder: BaseDatagramSocketGetIpMulticastTtlResponder,
    },
    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
    SetIpMulticastLoopback {
        value: bool,
        responder: BaseDatagramSocketSetIpMulticastLoopbackResponder,
    },
    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
    GetIpMulticastLoopback {
        responder: BaseDatagramSocketGetIpMulticastLoopbackResponder,
    },
    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
    AddIpMembership {
        membership: IpMulticastMembership,
        responder: BaseDatagramSocketAddIpMembershipResponder,
    },
    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
    DropIpMembership {
        membership: IpMulticastMembership,
        responder: BaseDatagramSocketDropIpMembershipResponder,
    },
    /// Set `SOL_IP` -> `IP_TRANSPARENT`
    SetIpTransparent {
        value: bool,
        responder: BaseDatagramSocketSetIpTransparentResponder,
    },
    /// Get `SOL_IP` -> `IP_TRANSPARENT`
    GetIpTransparent {
        responder: BaseDatagramSocketGetIpTransparentResponder,
    },
    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
    SetIpReceiveOriginalDestinationAddress {
        value: bool,
        responder: BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder,
    },
    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
    GetIpReceiveOriginalDestinationAddress {
        responder: BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
    AddIpv6Membership {
        membership: Ipv6MulticastMembership,
        responder: BaseDatagramSocketAddIpv6MembershipResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
    DropIpv6Membership {
        membership: Ipv6MulticastMembership,
        responder: BaseDatagramSocketDropIpv6MembershipResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    SetIpv6MulticastInterface {
        value: u64,
        responder: BaseDatagramSocketSetIpv6MulticastInterfaceResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    GetIpv6MulticastInterface {
        responder: BaseDatagramSocketGetIpv6MulticastInterfaceResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    SetIpv6UnicastHops {
        value: OptionalUint8,
        responder: BaseDatagramSocketSetIpv6UnicastHopsResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    GetIpv6UnicastHops {
        responder: BaseDatagramSocketGetIpv6UnicastHopsResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    SetIpv6ReceiveHopLimit {
        value: bool,
        responder: BaseDatagramSocketSetIpv6ReceiveHopLimitResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    GetIpv6ReceiveHopLimit {
        responder: BaseDatagramSocketGetIpv6ReceiveHopLimitResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    SetIpv6MulticastHops {
        value: OptionalUint8,
        responder: BaseDatagramSocketSetIpv6MulticastHopsResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    GetIpv6MulticastHops {
        responder: BaseDatagramSocketGetIpv6MulticastHopsResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    SetIpv6MulticastLoopback {
        value: bool,
        responder: BaseDatagramSocketSetIpv6MulticastLoopbackResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    GetIpv6MulticastLoopback {
        responder: BaseDatagramSocketGetIpv6MulticastLoopbackResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
    SetIpv6Only {
        value: bool,
        responder: BaseDatagramSocketSetIpv6OnlyResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
    GetIpv6Only {
        responder: BaseDatagramSocketGetIpv6OnlyResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    SetIpv6ReceiveTrafficClass {
        value: bool,
        responder: BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    GetIpv6ReceiveTrafficClass {
        responder: BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
    SetIpv6TrafficClass {
        value: OptionalUint8,
        responder: BaseDatagramSocketSetIpv6TrafficClassResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
    GetIpv6TrafficClass {
        responder: BaseDatagramSocketGetIpv6TrafficClassResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    SetIpv6ReceivePacketInfo {
        value: bool,
        responder: BaseDatagramSocketSetIpv6ReceivePacketInfoResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    GetIpv6ReceivePacketInfo {
        responder: BaseDatagramSocketGetIpv6ReceivePacketInfoResponder,
    },
    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
    GetOriginalDestination {
        responder: BaseDatagramSocketGetOriginalDestinationResponder,
    },
    /// Retrieves creation information from the socket.
    ///
    /// - response `domain` the socket's associated domain.
    /// - response `proto` the socket's associated protocol.
    GetInfo {
        responder: BaseDatagramSocketGetInfoResponder,
    },
}

impl BaseDatagramSocketRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_clone(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
        BaseDatagramSocketControlHandle,
    )> {
        if let BaseDatagramSocketRequest::Clone { request, control_handle } = self {
            Some((request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_close(self) -> Option<(BaseDatagramSocketCloseResponder)> {
        if let BaseDatagramSocketRequest::Close { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query(self) -> Option<(BaseDatagramSocketQueryResponder)> {
        if let BaseDatagramSocketRequest::Query { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_reuse_address(
        self,
    ) -> Option<(bool, BaseDatagramSocketSetReuseAddressResponder)> {
        if let BaseDatagramSocketRequest::SetReuseAddress { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_reuse_address(self) -> Option<(BaseDatagramSocketGetReuseAddressResponder)> {
        if let BaseDatagramSocketRequest::GetReuseAddress { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_error(self) -> Option<(BaseDatagramSocketGetErrorResponder)> {
        if let BaseDatagramSocketRequest::GetError { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_broadcast(self) -> Option<(bool, BaseDatagramSocketSetBroadcastResponder)> {
        if let BaseDatagramSocketRequest::SetBroadcast { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_broadcast(self) -> Option<(BaseDatagramSocketGetBroadcastResponder)> {
        if let BaseDatagramSocketRequest::GetBroadcast { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_send_buffer(self) -> Option<(u64, BaseDatagramSocketSetSendBufferResponder)> {
        if let BaseDatagramSocketRequest::SetSendBuffer { value_bytes, responder } = self {
            Some((value_bytes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_send_buffer(self) -> Option<(BaseDatagramSocketGetSendBufferResponder)> {
        if let BaseDatagramSocketRequest::GetSendBuffer { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_receive_buffer(
        self,
    ) -> Option<(u64, BaseDatagramSocketSetReceiveBufferResponder)> {
        if let BaseDatagramSocketRequest::SetReceiveBuffer { value_bytes, responder } = self {
            Some((value_bytes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_receive_buffer(self) -> Option<(BaseDatagramSocketGetReceiveBufferResponder)> {
        if let BaseDatagramSocketRequest::GetReceiveBuffer { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_keep_alive(self) -> Option<(bool, BaseDatagramSocketSetKeepAliveResponder)> {
        if let BaseDatagramSocketRequest::SetKeepAlive { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_keep_alive(self) -> Option<(BaseDatagramSocketGetKeepAliveResponder)> {
        if let BaseDatagramSocketRequest::GetKeepAlive { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_out_of_band_inline(
        self,
    ) -> Option<(bool, BaseDatagramSocketSetOutOfBandInlineResponder)> {
        if let BaseDatagramSocketRequest::SetOutOfBandInline { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_out_of_band_inline(
        self,
    ) -> Option<(BaseDatagramSocketGetOutOfBandInlineResponder)> {
        if let BaseDatagramSocketRequest::GetOutOfBandInline { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_no_check(self) -> Option<(bool, BaseDatagramSocketSetNoCheckResponder)> {
        if let BaseDatagramSocketRequest::SetNoCheck { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_no_check(self) -> Option<(BaseDatagramSocketGetNoCheckResponder)> {
        if let BaseDatagramSocketRequest::GetNoCheck { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_linger(self) -> Option<(bool, u32, BaseDatagramSocketSetLingerResponder)> {
        if let BaseDatagramSocketRequest::SetLinger { linger, length_secs, responder } = self {
            Some((linger, length_secs, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_linger(self) -> Option<(BaseDatagramSocketGetLingerResponder)> {
        if let BaseDatagramSocketRequest::GetLinger { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_reuse_port(self) -> Option<(bool, BaseDatagramSocketSetReusePortResponder)> {
        if let BaseDatagramSocketRequest::SetReusePort { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_reuse_port(self) -> Option<(BaseDatagramSocketGetReusePortResponder)> {
        if let BaseDatagramSocketRequest::GetReusePort { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_accept_conn(self) -> Option<(BaseDatagramSocketGetAcceptConnResponder)> {
        if let BaseDatagramSocketRequest::GetAcceptConn { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_bind_to_device(
        self,
    ) -> Option<(String, BaseDatagramSocketSetBindToDeviceResponder)> {
        if let BaseDatagramSocketRequest::SetBindToDevice { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_bind_to_device(self) -> Option<(BaseDatagramSocketGetBindToDeviceResponder)> {
        if let BaseDatagramSocketRequest::GetBindToDevice { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_bind_to_interface_index(
        self,
    ) -> Option<(u64, BaseDatagramSocketSetBindToInterfaceIndexResponder)> {
        if let BaseDatagramSocketRequest::SetBindToInterfaceIndex { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_bind_to_interface_index(
        self,
    ) -> Option<(BaseDatagramSocketGetBindToInterfaceIndexResponder)> {
        if let BaseDatagramSocketRequest::GetBindToInterfaceIndex { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_timestamp(
        self,
    ) -> Option<(TimestampOption, BaseDatagramSocketSetTimestampResponder)> {
        if let BaseDatagramSocketRequest::SetTimestamp { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_timestamp(self) -> Option<(BaseDatagramSocketGetTimestampResponder)> {
        if let BaseDatagramSocketRequest::GetTimestamp { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_mark(
        self,
    ) -> Option<(fidl_fuchsia_net::MarkDomain, OptionalUint32, BaseDatagramSocketSetMarkResponder)>
    {
        if let BaseDatagramSocketRequest::SetMark { domain, mark, responder } = self {
            Some((domain, mark, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_mark(
        self,
    ) -> Option<(fidl_fuchsia_net::MarkDomain, BaseDatagramSocketGetMarkResponder)> {
        if let BaseDatagramSocketRequest::GetMark { domain, responder } = self {
            Some((domain, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_cookie(self) -> Option<(BaseDatagramSocketGetCookieResponder)> {
        if let BaseDatagramSocketRequest::GetCookie { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind(
        self,
    ) -> Option<(fidl_fuchsia_net::SocketAddress, BaseDatagramSocketBindResponder)> {
        if let BaseDatagramSocketRequest::Bind { addr, responder } = self {
            Some((addr, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fidl_fuchsia_net::SocketAddress, BaseDatagramSocketConnectResponder)> {
        if let BaseDatagramSocketRequest::Connect { addr, responder } = self {
            Some((addr, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_disconnect(self) -> Option<(BaseDatagramSocketDisconnectResponder)> {
        if let BaseDatagramSocketRequest::Disconnect { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_sock_name(self) -> Option<(BaseDatagramSocketGetSockNameResponder)> {
        if let BaseDatagramSocketRequest::GetSockName { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_peer_name(self) -> Option<(BaseDatagramSocketGetPeerNameResponder)> {
        if let BaseDatagramSocketRequest::GetPeerName { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_shutdown(self) -> Option<(ShutdownMode, BaseDatagramSocketShutdownResponder)> {
        if let BaseDatagramSocketRequest::Shutdown { mode, responder } = self {
            Some((mode, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_type_of_service(
        self,
    ) -> Option<(u8, BaseDatagramSocketSetIpTypeOfServiceResponder)> {
        if let BaseDatagramSocketRequest::SetIpTypeOfService { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_type_of_service(
        self,
    ) -> Option<(BaseDatagramSocketGetIpTypeOfServiceResponder)> {
        if let BaseDatagramSocketRequest::GetIpTypeOfService { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_ttl(self) -> Option<(OptionalUint8, BaseDatagramSocketSetIpTtlResponder)> {
        if let BaseDatagramSocketRequest::SetIpTtl { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_ttl(self) -> Option<(BaseDatagramSocketGetIpTtlResponder)> {
        if let BaseDatagramSocketRequest::GetIpTtl { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_packet_info(
        self,
    ) -> Option<(bool, BaseDatagramSocketSetIpPacketInfoResponder)> {
        if let BaseDatagramSocketRequest::SetIpPacketInfo { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_packet_info(self) -> Option<(BaseDatagramSocketGetIpPacketInfoResponder)> {
        if let BaseDatagramSocketRequest::GetIpPacketInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_receive_type_of_service(
        self,
    ) -> Option<(bool, BaseDatagramSocketSetIpReceiveTypeOfServiceResponder)> {
        if let BaseDatagramSocketRequest::SetIpReceiveTypeOfService { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_receive_type_of_service(
        self,
    ) -> Option<(BaseDatagramSocketGetIpReceiveTypeOfServiceResponder)> {
        if let BaseDatagramSocketRequest::GetIpReceiveTypeOfService { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_receive_ttl(
        self,
    ) -> Option<(bool, BaseDatagramSocketSetIpReceiveTtlResponder)> {
        if let BaseDatagramSocketRequest::SetIpReceiveTtl { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_receive_ttl(self) -> Option<(BaseDatagramSocketGetIpReceiveTtlResponder)> {
        if let BaseDatagramSocketRequest::GetIpReceiveTtl { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_multicast_interface(
        self,
    ) -> Option<(
        u64,
        fidl_fuchsia_net::Ipv4Address,
        BaseDatagramSocketSetIpMulticastInterfaceResponder,
    )> {
        if let BaseDatagramSocketRequest::SetIpMulticastInterface { iface, address, responder } =
            self
        {
            Some((iface, address, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_multicast_interface(
        self,
    ) -> Option<(BaseDatagramSocketGetIpMulticastInterfaceResponder)> {
        if let BaseDatagramSocketRequest::GetIpMulticastInterface { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_multicast_ttl(
        self,
    ) -> Option<(OptionalUint8, BaseDatagramSocketSetIpMulticastTtlResponder)> {
        if let BaseDatagramSocketRequest::SetIpMulticastTtl { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_multicast_ttl(
        self,
    ) -> Option<(BaseDatagramSocketGetIpMulticastTtlResponder)> {
        if let BaseDatagramSocketRequest::GetIpMulticastTtl { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_multicast_loopback(
        self,
    ) -> Option<(bool, BaseDatagramSocketSetIpMulticastLoopbackResponder)> {
        if let BaseDatagramSocketRequest::SetIpMulticastLoopback { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_multicast_loopback(
        self,
    ) -> Option<(BaseDatagramSocketGetIpMulticastLoopbackResponder)> {
        if let BaseDatagramSocketRequest::GetIpMulticastLoopback { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_ip_membership(
        self,
    ) -> Option<(IpMulticastMembership, BaseDatagramSocketAddIpMembershipResponder)> {
        if let BaseDatagramSocketRequest::AddIpMembership { membership, responder } = self {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_drop_ip_membership(
        self,
    ) -> Option<(IpMulticastMembership, BaseDatagramSocketDropIpMembershipResponder)> {
        if let BaseDatagramSocketRequest::DropIpMembership { membership, responder } = self {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_transparent(
        self,
    ) -> Option<(bool, BaseDatagramSocketSetIpTransparentResponder)> {
        if let BaseDatagramSocketRequest::SetIpTransparent { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_transparent(self) -> Option<(BaseDatagramSocketGetIpTransparentResponder)> {
        if let BaseDatagramSocketRequest::GetIpTransparent { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_receive_original_destination_address(
        self,
    ) -> Option<(bool, BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder)> {
        if let BaseDatagramSocketRequest::SetIpReceiveOriginalDestinationAddress {
            value,
            responder,
        } = self
        {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_receive_original_destination_address(
        self,
    ) -> Option<(BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder)> {
        if let BaseDatagramSocketRequest::GetIpReceiveOriginalDestinationAddress { responder } =
            self
        {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_ipv6_membership(
        self,
    ) -> Option<(Ipv6MulticastMembership, BaseDatagramSocketAddIpv6MembershipResponder)> {
        if let BaseDatagramSocketRequest::AddIpv6Membership { membership, responder } = self {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_drop_ipv6_membership(
        self,
    ) -> Option<(Ipv6MulticastMembership, BaseDatagramSocketDropIpv6MembershipResponder)> {
        if let BaseDatagramSocketRequest::DropIpv6Membership { membership, responder } = self {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_multicast_interface(
        self,
    ) -> Option<(u64, BaseDatagramSocketSetIpv6MulticastInterfaceResponder)> {
        if let BaseDatagramSocketRequest::SetIpv6MulticastInterface { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_multicast_interface(
        self,
    ) -> Option<(BaseDatagramSocketGetIpv6MulticastInterfaceResponder)> {
        if let BaseDatagramSocketRequest::GetIpv6MulticastInterface { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_unicast_hops(
        self,
    ) -> Option<(OptionalUint8, BaseDatagramSocketSetIpv6UnicastHopsResponder)> {
        if let BaseDatagramSocketRequest::SetIpv6UnicastHops { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_unicast_hops(
        self,
    ) -> Option<(BaseDatagramSocketGetIpv6UnicastHopsResponder)> {
        if let BaseDatagramSocketRequest::GetIpv6UnicastHops { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_receive_hop_limit(
        self,
    ) -> Option<(bool, BaseDatagramSocketSetIpv6ReceiveHopLimitResponder)> {
        if let BaseDatagramSocketRequest::SetIpv6ReceiveHopLimit { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_receive_hop_limit(
        self,
    ) -> Option<(BaseDatagramSocketGetIpv6ReceiveHopLimitResponder)> {
        if let BaseDatagramSocketRequest::GetIpv6ReceiveHopLimit { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_multicast_hops(
        self,
    ) -> Option<(OptionalUint8, BaseDatagramSocketSetIpv6MulticastHopsResponder)> {
        if let BaseDatagramSocketRequest::SetIpv6MulticastHops { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_multicast_hops(
        self,
    ) -> Option<(BaseDatagramSocketGetIpv6MulticastHopsResponder)> {
        if let BaseDatagramSocketRequest::GetIpv6MulticastHops { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_multicast_loopback(
        self,
    ) -> Option<(bool, BaseDatagramSocketSetIpv6MulticastLoopbackResponder)> {
        if let BaseDatagramSocketRequest::SetIpv6MulticastLoopback { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_multicast_loopback(
        self,
    ) -> Option<(BaseDatagramSocketGetIpv6MulticastLoopbackResponder)> {
        if let BaseDatagramSocketRequest::GetIpv6MulticastLoopback { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_only(self) -> Option<(bool, BaseDatagramSocketSetIpv6OnlyResponder)> {
        if let BaseDatagramSocketRequest::SetIpv6Only { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_only(self) -> Option<(BaseDatagramSocketGetIpv6OnlyResponder)> {
        if let BaseDatagramSocketRequest::GetIpv6Only { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_receive_traffic_class(
        self,
    ) -> Option<(bool, BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder)> {
        if let BaseDatagramSocketRequest::SetIpv6ReceiveTrafficClass { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_receive_traffic_class(
        self,
    ) -> Option<(BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder)> {
        if let BaseDatagramSocketRequest::GetIpv6ReceiveTrafficClass { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_traffic_class(
        self,
    ) -> Option<(OptionalUint8, BaseDatagramSocketSetIpv6TrafficClassResponder)> {
        if let BaseDatagramSocketRequest::SetIpv6TrafficClass { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_traffic_class(
        self,
    ) -> Option<(BaseDatagramSocketGetIpv6TrafficClassResponder)> {
        if let BaseDatagramSocketRequest::GetIpv6TrafficClass { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_receive_packet_info(
        self,
    ) -> Option<(bool, BaseDatagramSocketSetIpv6ReceivePacketInfoResponder)> {
        if let BaseDatagramSocketRequest::SetIpv6ReceivePacketInfo { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_receive_packet_info(
        self,
    ) -> Option<(BaseDatagramSocketGetIpv6ReceivePacketInfoResponder)> {
        if let BaseDatagramSocketRequest::GetIpv6ReceivePacketInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_original_destination(
        self,
    ) -> Option<(BaseDatagramSocketGetOriginalDestinationResponder)> {
        if let BaseDatagramSocketRequest::GetOriginalDestination { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_info(self) -> Option<(BaseDatagramSocketGetInfoResponder)> {
        if let BaseDatagramSocketRequest::GetInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BaseDatagramSocketRequest::Clone { .. } => "clone",
            BaseDatagramSocketRequest::Close { .. } => "close",
            BaseDatagramSocketRequest::Query { .. } => "query",
            BaseDatagramSocketRequest::SetReuseAddress { .. } => "set_reuse_address",
            BaseDatagramSocketRequest::GetReuseAddress { .. } => "get_reuse_address",
            BaseDatagramSocketRequest::GetError { .. } => "get_error",
            BaseDatagramSocketRequest::SetBroadcast { .. } => "set_broadcast",
            BaseDatagramSocketRequest::GetBroadcast { .. } => "get_broadcast",
            BaseDatagramSocketRequest::SetSendBuffer { .. } => "set_send_buffer",
            BaseDatagramSocketRequest::GetSendBuffer { .. } => "get_send_buffer",
            BaseDatagramSocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
            BaseDatagramSocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
            BaseDatagramSocketRequest::SetKeepAlive { .. } => "set_keep_alive",
            BaseDatagramSocketRequest::GetKeepAlive { .. } => "get_keep_alive",
            BaseDatagramSocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
            BaseDatagramSocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
            BaseDatagramSocketRequest::SetNoCheck { .. } => "set_no_check",
            BaseDatagramSocketRequest::GetNoCheck { .. } => "get_no_check",
            BaseDatagramSocketRequest::SetLinger { .. } => "set_linger",
            BaseDatagramSocketRequest::GetLinger { .. } => "get_linger",
            BaseDatagramSocketRequest::SetReusePort { .. } => "set_reuse_port",
            BaseDatagramSocketRequest::GetReusePort { .. } => "get_reuse_port",
            BaseDatagramSocketRequest::GetAcceptConn { .. } => "get_accept_conn",
            BaseDatagramSocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
            BaseDatagramSocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
            BaseDatagramSocketRequest::SetBindToInterfaceIndex { .. } => {
                "set_bind_to_interface_index"
            }
            BaseDatagramSocketRequest::GetBindToInterfaceIndex { .. } => {
                "get_bind_to_interface_index"
            }
            BaseDatagramSocketRequest::SetTimestamp { .. } => "set_timestamp",
            BaseDatagramSocketRequest::GetTimestamp { .. } => "get_timestamp",
            BaseDatagramSocketRequest::SetMark { .. } => "set_mark",
            BaseDatagramSocketRequest::GetMark { .. } => "get_mark",
            BaseDatagramSocketRequest::GetCookie { .. } => "get_cookie",
            BaseDatagramSocketRequest::Bind { .. } => "bind",
            BaseDatagramSocketRequest::Connect { .. } => "connect",
            BaseDatagramSocketRequest::Disconnect { .. } => "disconnect",
            BaseDatagramSocketRequest::GetSockName { .. } => "get_sock_name",
            BaseDatagramSocketRequest::GetPeerName { .. } => "get_peer_name",
            BaseDatagramSocketRequest::Shutdown { .. } => "shutdown",
            BaseDatagramSocketRequest::SetIpTypeOfService { .. } => "set_ip_type_of_service",
            BaseDatagramSocketRequest::GetIpTypeOfService { .. } => "get_ip_type_of_service",
            BaseDatagramSocketRequest::SetIpTtl { .. } => "set_ip_ttl",
            BaseDatagramSocketRequest::GetIpTtl { .. } => "get_ip_ttl",
            BaseDatagramSocketRequest::SetIpPacketInfo { .. } => "set_ip_packet_info",
            BaseDatagramSocketRequest::GetIpPacketInfo { .. } => "get_ip_packet_info",
            BaseDatagramSocketRequest::SetIpReceiveTypeOfService { .. } => {
                "set_ip_receive_type_of_service"
            }
            BaseDatagramSocketRequest::GetIpReceiveTypeOfService { .. } => {
                "get_ip_receive_type_of_service"
            }
            BaseDatagramSocketRequest::SetIpReceiveTtl { .. } => "set_ip_receive_ttl",
            BaseDatagramSocketRequest::GetIpReceiveTtl { .. } => "get_ip_receive_ttl",
            BaseDatagramSocketRequest::SetIpMulticastInterface { .. } => {
                "set_ip_multicast_interface"
            }
            BaseDatagramSocketRequest::GetIpMulticastInterface { .. } => {
                "get_ip_multicast_interface"
            }
            BaseDatagramSocketRequest::SetIpMulticastTtl { .. } => "set_ip_multicast_ttl",
            BaseDatagramSocketRequest::GetIpMulticastTtl { .. } => "get_ip_multicast_ttl",
            BaseDatagramSocketRequest::SetIpMulticastLoopback { .. } => "set_ip_multicast_loopback",
            BaseDatagramSocketRequest::GetIpMulticastLoopback { .. } => "get_ip_multicast_loopback",
            BaseDatagramSocketRequest::AddIpMembership { .. } => "add_ip_membership",
            BaseDatagramSocketRequest::DropIpMembership { .. } => "drop_ip_membership",
            BaseDatagramSocketRequest::SetIpTransparent { .. } => "set_ip_transparent",
            BaseDatagramSocketRequest::GetIpTransparent { .. } => "get_ip_transparent",
            BaseDatagramSocketRequest::SetIpReceiveOriginalDestinationAddress { .. } => {
                "set_ip_receive_original_destination_address"
            }
            BaseDatagramSocketRequest::GetIpReceiveOriginalDestinationAddress { .. } => {
                "get_ip_receive_original_destination_address"
            }
            BaseDatagramSocketRequest::AddIpv6Membership { .. } => "add_ipv6_membership",
            BaseDatagramSocketRequest::DropIpv6Membership { .. } => "drop_ipv6_membership",
            BaseDatagramSocketRequest::SetIpv6MulticastInterface { .. } => {
                "set_ipv6_multicast_interface"
            }
            BaseDatagramSocketRequest::GetIpv6MulticastInterface { .. } => {
                "get_ipv6_multicast_interface"
            }
            BaseDatagramSocketRequest::SetIpv6UnicastHops { .. } => "set_ipv6_unicast_hops",
            BaseDatagramSocketRequest::GetIpv6UnicastHops { .. } => "get_ipv6_unicast_hops",
            BaseDatagramSocketRequest::SetIpv6ReceiveHopLimit { .. } => {
                "set_ipv6_receive_hop_limit"
            }
            BaseDatagramSocketRequest::GetIpv6ReceiveHopLimit { .. } => {
                "get_ipv6_receive_hop_limit"
            }
            BaseDatagramSocketRequest::SetIpv6MulticastHops { .. } => "set_ipv6_multicast_hops",
            BaseDatagramSocketRequest::GetIpv6MulticastHops { .. } => "get_ipv6_multicast_hops",
            BaseDatagramSocketRequest::SetIpv6MulticastLoopback { .. } => {
                "set_ipv6_multicast_loopback"
            }
            BaseDatagramSocketRequest::GetIpv6MulticastLoopback { .. } => {
                "get_ipv6_multicast_loopback"
            }
            BaseDatagramSocketRequest::SetIpv6Only { .. } => "set_ipv6_only",
            BaseDatagramSocketRequest::GetIpv6Only { .. } => "get_ipv6_only",
            BaseDatagramSocketRequest::SetIpv6ReceiveTrafficClass { .. } => {
                "set_ipv6_receive_traffic_class"
            }
            BaseDatagramSocketRequest::GetIpv6ReceiveTrafficClass { .. } => {
                "get_ipv6_receive_traffic_class"
            }
            BaseDatagramSocketRequest::SetIpv6TrafficClass { .. } => "set_ipv6_traffic_class",
            BaseDatagramSocketRequest::GetIpv6TrafficClass { .. } => "get_ipv6_traffic_class",
            BaseDatagramSocketRequest::SetIpv6ReceivePacketInfo { .. } => {
                "set_ipv6_receive_packet_info"
            }
            BaseDatagramSocketRequest::GetIpv6ReceivePacketInfo { .. } => {
                "get_ipv6_receive_packet_info"
            }
            BaseDatagramSocketRequest::GetOriginalDestination { .. } => "get_original_destination",
            BaseDatagramSocketRequest::GetInfo { .. } => "get_info",
        }
    }
}

#[derive(Debug, Clone)]
pub struct BaseDatagramSocketControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for BaseDatagramSocketControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl BaseDatagramSocketControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketCloseResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketCloseResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketCloseResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketCloseResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
                result,
                self.tx_id,
                0x5ac5d459ad7f657e,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketQueryResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketQueryResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketQueryResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketQueryResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(protocol);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(protocol);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
            (protocol,),
            self.tx_id,
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetReuseAddressResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetReuseAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetReuseAddressResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetReuseAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x1fd74ee8b9a4a876,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetReuseAddressResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetReuseAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetReuseAddressResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetReuseAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetReuseAddressResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x67b7206b8d1bc0a5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetErrorResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetErrorResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetErrorResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetErrorResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x5aad39b33e5f6ebb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetBroadcastResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetBroadcastResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetBroadcastResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetBroadcastResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6023e081ce3cd947,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetBroadcastResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetBroadcastResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetBroadcastResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetBroadcastResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetBroadcastResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x68796fc556f9780d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetSendBufferResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetSendBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetSendBufferResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetSendBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x756eac32d73a7a70,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetSendBufferResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetSendBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetSendBufferResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetSendBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetSendBufferResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value_bytes| (value_bytes,)),
            self.tx_id,
            0x78a52fd9c7b2410b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetReceiveBufferResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetReceiveBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetReceiveBufferResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetReceiveBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6b0cf2f1919c7001,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetReceiveBufferResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetReceiveBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetReceiveBufferResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetReceiveBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetReceiveBufferResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value_bytes| (value_bytes,)),
            self.tx_id,
            0x14c1a4b64f709e5c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetKeepAliveResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetKeepAliveResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetKeepAliveResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetKeepAliveResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x572df8f0b920d2c7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetKeepAliveResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetKeepAliveResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetKeepAliveResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetKeepAliveResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetKeepAliveResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2dd29d3215f2c9d2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetOutOfBandInlineResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetOutOfBandInlineResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetOutOfBandInlineResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetOutOfBandInlineResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x3ecb49968bee439,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetOutOfBandInlineResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetOutOfBandInlineResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetOutOfBandInlineResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetOutOfBandInlineResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetOutOfBandInlineResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x348c1ab3aeca1745,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetNoCheckResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetNoCheckResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetNoCheckResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetNoCheckResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6bbf00c53a4c78c2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetNoCheckResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetNoCheckResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetNoCheckResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetNoCheckResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetNoCheckResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2cd4249286417694,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetLingerResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetLingerResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetLingerResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetLingerResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x45386351246e998e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetLingerResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetLingerResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetLingerResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetLingerResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetLingerResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x48eb20fc5ccb0e45,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetReusePortResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetReusePortResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetReusePortResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetReusePortResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x24dd3e5cb36d9ccb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetReusePortResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetReusePortResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetReusePortResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetReusePortResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetReusePortResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x7a112c1ab54ff828,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetAcceptConnResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetAcceptConnResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetAcceptConnResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetAcceptConnResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetAcceptConnResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x67ce6db6c2ec8966,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetBindToDeviceResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetBindToDeviceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetBindToDeviceResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetBindToDeviceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x2118b483f28aafc4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetBindToDeviceResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetBindToDeviceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetBindToDeviceResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetBindToDeviceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetBindToDeviceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x1ab1fbf0ef7906c8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetBindToInterfaceIndexResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetBindToInterfaceIndexResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetBindToInterfaceIndexResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetBindToInterfaceIndexResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6e387a0def00821,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetBindToInterfaceIndexResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetBindToInterfaceIndexResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetBindToInterfaceIndexResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetBindToInterfaceIndexResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetBindToInterfaceIndexResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x59c31dd3e3078295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetTimestampResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetTimestampResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetTimestampResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetTimestampResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x285d6516c263d839,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetTimestampResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetTimestampResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetTimestampResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetTimestampResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetTimestampResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x49f2fffbbcc2bd27,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetMarkResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetMarkResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetMarkResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetMarkResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6ead6de09f653236,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetMarkResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetMarkResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetMarkResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetMarkResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetMarkResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|mark| (mark,)),
            self.tx_id,
            0x57a2752c61d93d47,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetCookieResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetCookieResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetCookieResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetCookieResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetCookieResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2c2f47fd8f924e52,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketBindResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketBindResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketBindResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketBindResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x4bc6400ae92125d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketConnectResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketConnectResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketConnectResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketConnectResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x5f05f19bfdd38871,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketDisconnectResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketDisconnectResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketDisconnectResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketDisconnectResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x74e63b91f7b29b2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetSockNameResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetSockNameResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetSockNameResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetSockNameResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetSockNameResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|addr| (addr,)),
            self.tx_id,
            0x475f23f84a1a4f85,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetPeerNameResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetPeerNameResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetPeerNameResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetPeerNameResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetPeerNameResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|addr| (addr,)),
            self.tx_id,
            0x1ffecf4bd5b6432e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketShutdownResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketShutdownResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketShutdownResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketShutdownResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x247f38b6db68c336,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetIpTypeOfServiceResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x995c600475b6d46,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetIpTypeOfServiceResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpTypeOfServiceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x3814a04259f75fcb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpTtlResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetIpTtlResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x29e2424b433ae1ef,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpTtlResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetIpTtlResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpTtlResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x47e47fa1f24da471,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpPacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpPacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetIpPacketInfoResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpPacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x392d16bee20c0e16,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpPacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpPacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetIpPacketInfoResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpPacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpPacketInfoResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x54b505f242280740,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpReceiveTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpReceiveTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetIpReceiveTypeOfServiceResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpReceiveTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6c4f6714995f84ef,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpReceiveTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpReceiveTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetIpReceiveTypeOfServiceResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpReceiveTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4158ba7dc2795960,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpReceiveTtlResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpReceiveTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetIpReceiveTtlResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpReceiveTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x46f15be0ce0ab82b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpReceiveTtlResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpReceiveTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetIpReceiveTtlResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpReceiveTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpReceiveTtlResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x678ddd5a5dfa2eb5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpMulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpMulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetIpMulticastInterfaceResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpMulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x752fbfa9b12befe,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpMulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpMulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetIpMulticastInterfaceResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpMulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpMulticastInterfaceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x320bd14c4df046c4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpMulticastTtlResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpMulticastTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetIpMulticastTtlResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpMulticastTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x63134d53772916a1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpMulticastTtlResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpMulticastTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetIpMulticastTtlResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpMulticastTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpMulticastTtlResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4665cd378f39e1a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpMulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpMulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetIpMulticastLoopbackResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpMulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x20c55c11f00943ea,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpMulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpMulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetIpMulticastLoopbackResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpMulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpMulticastLoopbackResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x3b6b26ff558298f2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketAddIpMembershipResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketAddIpMembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketAddIpMembershipResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketAddIpMembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x76bc7df115a3b4d0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketDropIpMembershipResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketDropIpMembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketDropIpMembershipResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketDropIpMembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x2888f3099188d03,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpTransparentResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpTransparentResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetIpTransparentResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpTransparentResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x1ae532b0c066e3a0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpTransparentResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpTransparentResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetIpTransparentResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpTransparentResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpTransparentResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x51d43695962ebfb5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder
    for BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder
{
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x4722b4ce52f7840,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder
    for BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder
{
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2a0e7dc5d6bfdfe9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketAddIpv6MembershipResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketAddIpv6MembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketAddIpv6MembershipResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketAddIpv6MembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x7c94727acb4ea4b3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketDropIpv6MembershipResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketDropIpv6MembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketDropIpv6MembershipResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketDropIpv6MembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x42104c70ccaba304,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpv6MulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpv6MulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6MulticastInterfaceResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpv6MulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x135f76db3774ab3b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpv6MulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpv6MulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6MulticastInterfaceResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpv6MulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x1f26fcdd348f1882,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpv6UnicastHopsResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpv6UnicastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6UnicastHopsResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpv6UnicastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x157d51e98f462859,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpv6UnicastHopsResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpv6UnicastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6UnicastHopsResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpv6UnicastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6UnicastHopsResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x21f4641cad8bd8d2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpv6ReceiveHopLimitResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpv6ReceiveHopLimitResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6ReceiveHopLimitResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpv6ReceiveHopLimitResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x5c24808ed2e84a1e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpv6ReceiveHopLimitResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpv6ReceiveHopLimitResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6ReceiveHopLimitResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpv6ReceiveHopLimitResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x341e06689885b4c0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpv6MulticastHopsResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpv6MulticastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6MulticastHopsResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpv6MulticastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x25b9cd4d181f82c1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpv6MulticastHopsResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpv6MulticastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6MulticastHopsResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpv6MulticastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6MulticastHopsResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x52916948a365012a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpv6MulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpv6MulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6MulticastLoopbackResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpv6MulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x55701c409ff41b40,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpv6MulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpv6MulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6MulticastLoopbackResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpv6MulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4415b701fde319c3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpv6OnlyResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpv6OnlyResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6OnlyResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpv6OnlyResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x4873f1364758cbba,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpv6OnlyResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpv6OnlyResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6OnlyResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpv6OnlyResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6OnlyResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4aa3340a1a26b89c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x58f07c8788d099a0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2e334df1da553ffa,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpv6TrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpv6TrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6TrafficClassResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpv6TrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6af077800c5a0b4f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpv6TrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpv6TrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6TrafficClassResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpv6TrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6TrafficClassResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x6baf6eed8fc2f04,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketSetIpv6ReceivePacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketSetIpv6ReceivePacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6ReceivePacketInfoResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketSetIpv6ReceivePacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x19259775b1a92768,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetIpv6ReceivePacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetIpv6ReceivePacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6ReceivePacketInfoResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetIpv6ReceivePacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x7acd4a2775baec75,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetOriginalDestinationResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetOriginalDestinationResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetOriginalDestinationResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetOriginalDestinationResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetOriginalDestinationResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x38bf28f0dafdbac0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseDatagramSocketGetInfoResponder {
    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseDatagramSocketGetInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseDatagramSocketGetInfoResponder {
    type ControlHandle = BaseDatagramSocketControlHandle;

    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseDatagramSocketGetInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseDatagramSocketGetInfoResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x48aa0a1f6a32d2ed,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct BaseNetworkSocketMarker;

impl fidl::endpoints::ProtocolMarker for BaseNetworkSocketMarker {
    type Proxy = BaseNetworkSocketProxy;
    type RequestStream = BaseNetworkSocketRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = BaseNetworkSocketSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) BaseNetworkSocket";
}
pub type BaseNetworkSocketBindResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketConnectResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketDisconnectResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetSockNameResult =
    Result<fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetPeerNameResult =
    Result<fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketShutdownResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpTypeOfServiceResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpTypeOfServiceResult = Result<u8, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpTtlResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpTtlResult = Result<u8, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpPacketInfoResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpPacketInfoResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpReceiveTypeOfServiceResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpReceiveTypeOfServiceResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpReceiveTtlResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpReceiveTtlResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpMulticastInterfaceResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpMulticastInterfaceResult =
    Result<fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpMulticastTtlResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpMulticastTtlResult = Result<u8, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpMulticastLoopbackResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpMulticastLoopbackResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketAddIpMembershipResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketDropIpMembershipResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpTransparentResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpTransparentResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult =
    Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult =
    Result<bool, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketAddIpv6MembershipResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketDropIpv6MembershipResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpv6MulticastInterfaceResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpv6MulticastInterfaceResult = Result<u64, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpv6UnicastHopsResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpv6UnicastHopsResult = Result<u8, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpv6ReceiveHopLimitResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpv6ReceiveHopLimitResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpv6MulticastHopsResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpv6MulticastHopsResult = Result<u8, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpv6MulticastLoopbackResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpv6MulticastLoopbackResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpv6OnlyResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpv6OnlyResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpv6ReceiveTrafficClassResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpv6ReceiveTrafficClassResult =
    Result<bool, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpv6TrafficClassResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpv6TrafficClassResult = Result<u8, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketSetIpv6ReceivePacketInfoResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetIpv6ReceivePacketInfoResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type BaseNetworkSocketGetOriginalDestinationResult =
    Result<fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>;

pub trait BaseNetworkSocketProxyInterface: Send + Sync {
    fn r#clone(
        &self,
        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error>;
    type CloseResponseFut: std::future::Future<
            Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
        > + Send;
    fn r#close(&self) -> Self::CloseResponseFut;
    type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
    fn r#query(&self) -> Self::QueryResponseFut;
    type SetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketSetReuseAddressResult, fidl::Error>>
        + Send;
    fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
    type GetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketGetReuseAddressResult, fidl::Error>>
        + Send;
    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
    type GetErrorResponseFut: std::future::Future<Output = Result<BaseSocketGetErrorResult, fidl::Error>>
        + Send;
    fn r#get_error(&self) -> Self::GetErrorResponseFut;
    type SetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketSetBroadcastResult, fidl::Error>>
        + Send;
    fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
    type GetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketGetBroadcastResult, fidl::Error>>
        + Send;
    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
    type SetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetSendBufferResult, fidl::Error>>
        + Send;
    fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
    type GetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetSendBufferResult, fidl::Error>>
        + Send;
    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
    type SetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetReceiveBufferResult, fidl::Error>>
        + Send;
    fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
    type GetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetReceiveBufferResult, fidl::Error>>
        + Send;
    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
    type SetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketSetKeepAliveResult, fidl::Error>>
        + Send;
    fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
    type GetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketGetKeepAliveResult, fidl::Error>>
        + Send;
    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
    type SetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketSetOutOfBandInlineResult, fidl::Error>>
        + Send;
    fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
    type GetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketGetOutOfBandInlineResult, fidl::Error>>
        + Send;
    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
    type SetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketSetNoCheckResult, fidl::Error>>
        + Send;
    fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
    type GetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketGetNoCheckResult, fidl::Error>>
        + Send;
    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
    type SetLingerResponseFut: std::future::Future<Output = Result<BaseSocketSetLingerResult, fidl::Error>>
        + Send;
    fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
    type GetLingerResponseFut: std::future::Future<Output = Result<BaseSocketGetLingerResult, fidl::Error>>
        + Send;
    fn r#get_linger(&self) -> Self::GetLingerResponseFut;
    type SetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketSetReusePortResult, fidl::Error>>
        + Send;
    fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
    type GetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketGetReusePortResult, fidl::Error>>
        + Send;
    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
    type GetAcceptConnResponseFut: std::future::Future<Output = Result<BaseSocketGetAcceptConnResult, fidl::Error>>
        + Send;
    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
    type SetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToDeviceResult, fidl::Error>>
        + Send;
    fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
    type GetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToDeviceResult, fidl::Error>>
        + Send;
    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
    type SetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error>>
        + Send;
    fn r#set_bind_to_interface_index(&self, value: u64)
    -> Self::SetBindToInterfaceIndexResponseFut;
    type GetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error>>
        + Send;
    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
    type SetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketSetTimestampResult, fidl::Error>>
        + Send;
    fn r#set_timestamp(&self, value: TimestampOption) -> Self::SetTimestampResponseFut;
    type GetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketGetTimestampResult, fidl::Error>>
        + Send;
    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
    type SetMarkResponseFut: std::future::Future<Output = Result<BaseSocketSetMarkResult, fidl::Error>>
        + Send;
    fn r#set_mark(
        &self,
        domain: fidl_fuchsia_net::MarkDomain,
        mark: &OptionalUint32,
    ) -> Self::SetMarkResponseFut;
    type GetMarkResponseFut: std::future::Future<Output = Result<BaseSocketGetMarkResult, fidl::Error>>
        + Send;
    fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
    type GetCookieResponseFut: std::future::Future<Output = Result<BaseSocketGetCookieResult, fidl::Error>>
        + Send;
    fn r#get_cookie(&self) -> Self::GetCookieResponseFut;
    type BindResponseFut: std::future::Future<Output = Result<BaseNetworkSocketBindResult, fidl::Error>>
        + Send;
    fn r#bind(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut;
    type ConnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketConnectResult, fidl::Error>>
        + Send;
    fn r#connect(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut;
    type DisconnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDisconnectResult, fidl::Error>>
        + Send;
    fn r#disconnect(&self) -> Self::DisconnectResponseFut;
    type GetSockNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetSockNameResult, fidl::Error>>
        + Send;
    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut;
    type GetPeerNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetPeerNameResult, fidl::Error>>
        + Send;
    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut;
    type ShutdownResponseFut: std::future::Future<Output = Result<BaseNetworkSocketShutdownResult, fidl::Error>>
        + Send;
    fn r#shutdown(&self, mode: ShutdownMode) -> Self::ShutdownResponseFut;
    type SetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>>
        + Send;
    fn r#set_ip_type_of_service(&self, value: u8) -> Self::SetIpTypeOfServiceResponseFut;
    type GetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>>
        + Send;
    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut;
    type SetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTtlResult, fidl::Error>>
        + Send;
    fn r#set_ip_ttl(&self, value: &OptionalUint8) -> Self::SetIpTtlResponseFut;
    type GetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTtlResult, fidl::Error>>
        + Send;
    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut;
    type SetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>>
        + Send;
    fn r#set_ip_packet_info(&self, value: bool) -> Self::SetIpPacketInfoResponseFut;
    type GetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>>
        + Send;
    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut;
    type SetIpReceiveTypeOfServiceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error>,
        > + Send;
    fn r#set_ip_receive_type_of_service(
        &self,
        value: bool,
    ) -> Self::SetIpReceiveTypeOfServiceResponseFut;
    type GetIpReceiveTypeOfServiceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error>,
        > + Send;
    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut;
    type SetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>>
        + Send;
    fn r#set_ip_receive_ttl(&self, value: bool) -> Self::SetIpReceiveTtlResponseFut;
    type GetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>>
        + Send;
    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut;
    type SetIpMulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#set_ip_multicast_interface(
        &self,
        iface: u64,
        address: &fidl_fuchsia_net::Ipv4Address,
    ) -> Self::SetIpMulticastInterfaceResponseFut;
    type GetIpMulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut;
    type SetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>>
        + Send;
    fn r#set_ip_multicast_ttl(&self, value: &OptionalUint8) -> Self::SetIpMulticastTtlResponseFut;
    type GetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>>
        + Send;
    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut;
    type SetIpMulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#set_ip_multicast_loopback(&self, value: bool) -> Self::SetIpMulticastLoopbackResponseFut;
    type GetIpMulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut;
    type AddIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error>>
        + Send;
    fn r#add_ip_membership(
        &self,
        membership: &IpMulticastMembership,
    ) -> Self::AddIpMembershipResponseFut;
    type DropIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error>>
        + Send;
    fn r#drop_ip_membership(
        &self,
        membership: &IpMulticastMembership,
    ) -> Self::DropIpMembershipResponseFut;
    type SetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error>>
        + Send;
    fn r#set_ip_transparent(&self, value: bool) -> Self::SetIpTransparentResponseFut;
    type GetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error>>
        + Send;
    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut;
    type SetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
            Output = Result<
                BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
                fidl::Error,
            >,
        > + Send;
    fn r#set_ip_receive_original_destination_address(
        &self,
        value: bool,
    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut;
    type GetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
            Output = Result<
                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
                fidl::Error,
            >,
        > + Send;
    fn r#get_ip_receive_original_destination_address(
        &self,
    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut;
    type AddIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>>
        + Send;
    fn r#add_ipv6_membership(
        &self,
        membership: &Ipv6MulticastMembership,
    ) -> Self::AddIpv6MembershipResponseFut;
    type DropIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>>
        + Send;
    fn r#drop_ipv6_membership(
        &self,
        membership: &Ipv6MulticastMembership,
    ) -> Self::DropIpv6MembershipResponseFut;
    type SetIpv6MulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_multicast_interface(
        &self,
        value: u64,
    ) -> Self::SetIpv6MulticastInterfaceResponseFut;
    type GetIpv6MulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut;
    type SetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>>
        + Send;
    fn r#set_ipv6_unicast_hops(&self, value: &OptionalUint8)
    -> Self::SetIpv6UnicastHopsResponseFut;
    type GetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>>
        + Send;
    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut;
    type SetIpv6ReceiveHopLimitResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_receive_hop_limit(&self, value: bool) -> Self::SetIpv6ReceiveHopLimitResponseFut;
    type GetIpv6ReceiveHopLimitResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut;
    type SetIpv6MulticastHopsResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_multicast_hops(
        &self,
        value: &OptionalUint8,
    ) -> Self::SetIpv6MulticastHopsResponseFut;
    type GetIpv6MulticastHopsResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut;
    type SetIpv6MulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_multicast_loopback(
        &self,
        value: bool,
    ) -> Self::SetIpv6MulticastLoopbackResponseFut;
    type GetIpv6MulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut;
    type SetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error>>
        + Send;
    fn r#set_ipv6_only(&self, value: bool) -> Self::SetIpv6OnlyResponseFut;
    type GetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error>>
        + Send;
    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut;
    type SetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_receive_traffic_class(
        &self,
        value: bool,
    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut;
    type GetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut;
    type SetIpv6TrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_traffic_class(
        &self,
        value: &OptionalUint8,
    ) -> Self::SetIpv6TrafficClassResponseFut;
    type GetIpv6TrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut;
    type SetIpv6ReceivePacketInfoResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_receive_packet_info(
        &self,
        value: bool,
    ) -> Self::SetIpv6ReceivePacketInfoResponseFut;
    type GetIpv6ReceivePacketInfoResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut;
    type GetOriginalDestinationResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error>,
        > + Send;
    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct BaseNetworkSocketSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for BaseNetworkSocketSynchronousProxy {
    type Proxy = BaseNetworkSocketProxy;
    type Protocol = BaseNetworkSocketMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl BaseNetworkSocketSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <BaseNetworkSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketEvent, fidl::Error> {
        BaseNetworkSocketEvent::decode(self.client.wait_for_event(deadline)?)
    }

    pub fn r#clone(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_unknown::QueryableQueryResponse,
        >(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.protocol)
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#set_reuse_address(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetReuseAddressRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x1fd74ee8b9a4a876,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#get_reuse_address(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetReuseAddressResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Get `SOL_SOCKET` -> `SO_ERROR`.
    /// Returns the last error if there is an error set on the socket.
    pub fn r#get_error(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x5aad39b33e5f6ebb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#set_broadcast(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetBroadcastRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x6023e081ce3cd947,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#get_broadcast(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetBroadcastResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x68796fc556f9780d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#set_send_buffer(
        &self,
        mut value_bytes: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetSendBufferRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value_bytes,),
                0x756eac32d73a7a70,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#get_send_buffer(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetSendBufferResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value_bytes))
    }

    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#set_receive_buffer(
        &self,
        mut value_bytes: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseSocketSetReceiveBufferRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value_bytes,),
                    0x6b0cf2f1919c7001,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#get_receive_buffer(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetReceiveBufferResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value_bytes))
    }

    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#set_keep_alive(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetKeepAliveRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x572df8f0b920d2c7,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#get_keep_alive(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetKeepAliveResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x2dd29d3215f2c9d2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#set_out_of_band_inline(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseSocketSetOutOfBandInlineRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x3ecb49968bee439,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#get_out_of_band_inline(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetOutOfBandInlineResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#set_no_check(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetNoCheckRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x6bbf00c53a4c78c2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#get_no_check(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetNoCheckResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x2cd4249286417694,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#set_linger(
        &self,
        mut linger: bool,
        mut length_secs: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetLingerRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (linger, length_secs),
                0x45386351246e998e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#get_linger(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetLingerResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x48eb20fc5ccb0e45,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| (x.linger, x.length_secs)))
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#set_reuse_port(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetReusePortRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x24dd3e5cb36d9ccb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#get_reuse_port(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetReusePortResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x7a112c1ab54ff828,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
    pub fn r#get_accept_conn(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetAcceptConnResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#set_bind_to_device(
        &self,
        mut value: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetBindToDeviceRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x2118b483f28aafc4,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#get_bind_to_device(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetBindToDeviceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    /// If `value` is 0, this clears the bound interface.
    pub fn r#set_bind_to_interface_index(
        &self,
        mut value: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x6e387a0def00821,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    pub fn r#get_bind_to_interface_index(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetBindToInterfaceIndexResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#set_timestamp(
        &self,
        mut value: TimestampOption,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetTimestampRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x285d6516c263d839,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#get_timestamp(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetTimestampResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x49f2fffbbcc2bd27,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be set independently in each domain.
    pub fn r#set_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        mut mark: &OptionalUint32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetMarkRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (domain, mark),
                0x6ead6de09f653236,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be retrieved independently in each domain.
    pub fn r#get_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketGetMarkRequest, fidl::encoding::ResultType<
                BaseSocketGetMarkResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (domain,),
                0x57a2752c61d93d47,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.mark))
    }

    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
    pub fn r#get_cookie(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetCookieResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetCookieResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x2c2f47fd8f924e52,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Sets the local address used for the socket.
    pub fn r#bind(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketBindRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (addr,),
                0x4bc6400ae92125d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Initiates a connection to a remote address.
    pub fn r#connect(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketConnectRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (addr,),
                0x5f05f19bfdd38871,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Clears connection information from this socket.
    pub fn r#disconnect(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x74e63b91f7b29b2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Retrieves the local socket address.
    pub fn r#get_sock_name(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetSockNameResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x475f23f84a1a4f85, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.addr))
    }

    /// Retrieves the remote socket address.
    pub fn r#get_peer_name(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetPeerNameResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x1ffecf4bd5b6432e, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.addr))
    }

    /// Shuts down part of the socket.
    pub fn r#shutdown(
        &self,
        mut mode: ShutdownMode,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketShutdownRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (mode,),
                0x247f38b6db68c336,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IP` -> `IP_TOS`.
    pub fn r#set_ip_type_of_service(
        &self,
        mut value: u8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpTypeOfServiceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x995c600475b6d46,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_TOS`.
    pub fn r#get_ip_type_of_service(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpTypeOfServiceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x3814a04259f75fcb, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_TTL`.
    pub fn r#set_ip_ttl(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketSetIpTtlRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x29e2424b433ae1ef,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_TTL`.
    pub fn r#get_ip_ttl(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpTtlResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x47e47fa1f24da471, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#set_ip_packet_info(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x392d16bee20c0e16,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#get_ip_packet_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpPacketInfoResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x54b505f242280740, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#set_ip_receive_type_of_service(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x6c4f6714995f84ef,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#get_ip_receive_type_of_service(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4158ba7dc2795960, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#set_ip_receive_ttl(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x46f15be0ce0ab82b,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#get_ip_receive_ttl(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpReceiveTtlResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x678ddd5a5dfa2eb5, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#set_ip_multicast_interface(
        &self,
        mut iface: u64,
        mut address: &fidl_fuchsia_net::Ipv4Address,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpMulticastInterfaceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (iface, address,),
            0x752fbfa9b12befe,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#get_ip_multicast_interface(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpMulticastInterfaceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x320bd14c4df046c4, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#set_ip_multicast_ttl(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x63134d53772916a1,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#get_ip_multicast_ttl(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpMulticastTtlResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4665cd378f39e1a, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#set_ip_multicast_loopback(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpMulticastLoopbackRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x20c55c11f00943ea,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#get_ip_multicast_loopback(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpMulticastLoopbackResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x3b6b26ff558298f2, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
    pub fn r#add_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (membership,),
                    0x76bc7df115a3b4d0,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
    pub fn r#drop_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (membership,),
                    0x2888f3099188d03,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#set_ip_transparent(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x1ae532b0c066e3a0,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#get_ip_transparent(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpTransparentResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x51d43695962ebfb5, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#set_ip_receive_original_destination_address(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x4722b4ce52f7840,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#get_ip_receive_original_destination_address(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x2a0e7dc5d6bfdfe9, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
    pub fn r#add_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (membership,),
                    0x7c94727acb4ea4b3,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
    pub fn r#drop_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketDropIpv6MembershipRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (membership,),
            0x42104c70ccaba304,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#set_ipv6_multicast_interface(
        &self,
        mut value: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x135f76db3774ab3b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#get_ipv6_multicast_interface(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x1f26fcdd348f1882, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#set_ipv6_unicast_hops(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6UnicastHopsRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x157d51e98f462859,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#get_ipv6_unicast_hops(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6UnicastHopsResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x21f4641cad8bd8d2, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#set_ipv6_receive_hop_limit(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x5c24808ed2e84a1e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#get_ipv6_receive_hop_limit(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x341e06689885b4c0, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#set_ipv6_multicast_hops(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6MulticastHopsRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x25b9cd4d181f82c1,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#get_ipv6_multicast_hops(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6MulticastHopsResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x52916948a365012a, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#set_ipv6_multicast_loopback(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x55701c409ff41b40,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#get_ipv6_multicast_loopback(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4415b701fde319c3, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#set_ipv6_only(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x4873f1364758cbba,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#get_ipv6_only(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6OnlyResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4aa3340a1a26b89c, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#set_ipv6_receive_traffic_class(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x58f07c8788d099a0,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#get_ipv6_receive_traffic_class(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x2e334df1da553ffa, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
    pub fn r#set_ipv6_traffic_class(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6TrafficClassRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x6af077800c5a0b4f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
    pub fn r#get_ipv6_traffic_class(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6TrafficClassResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x6baf6eed8fc2f04, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#set_ipv6_receive_packet_info(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x19259775b1a92768,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#get_ipv6_receive_packet_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x7acd4a2775baec75, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
    pub fn r#get_original_destination(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetOriginalDestinationResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x38bf28f0dafdbac0, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }
}

#[cfg(target_os = "fuchsia")]
impl From<BaseNetworkSocketSynchronousProxy> for zx::Handle {
    fn from(value: BaseNetworkSocketSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for BaseNetworkSocketSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for BaseNetworkSocketSynchronousProxy {
    type Protocol = BaseNetworkSocketMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<BaseNetworkSocketMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct BaseNetworkSocketProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for BaseNetworkSocketProxy {
    type Protocol = BaseNetworkSocketMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl BaseNetworkSocketProxy {
    /// Create a new Proxy for fuchsia.posix.socket/BaseNetworkSocket.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <BaseNetworkSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> BaseNetworkSocketEventStream {
        BaseNetworkSocketEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#clone(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        BaseNetworkSocketProxyInterface::r#clone(self, request)
    }

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#close(self)
    }

    pub fn r#query(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        BaseNetworkSocketProxyInterface::r#query(self)
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#set_reuse_address(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_reuse_address(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#get_reuse_address(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_reuse_address(self)
    }

    /// Get `SOL_SOCKET` -> `SO_ERROR`.
    /// Returns the last error if there is an error set on the socket.
    pub fn r#get_error(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetErrorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_error(self)
    }

    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#set_broadcast(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_broadcast(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#get_broadcast(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_broadcast(self)
    }

    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#set_send_buffer(
        &self,
        mut value_bytes: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_send_buffer(self, value_bytes)
    }

    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#get_send_buffer(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_send_buffer(self)
    }

    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#set_receive_buffer(
        &self,
        mut value_bytes: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_receive_buffer(self, value_bytes)
    }

    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#get_receive_buffer(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_receive_buffer(self)
    }

    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#set_keep_alive(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_keep_alive(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#get_keep_alive(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_keep_alive(self)
    }

    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#set_out_of_band_inline(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_out_of_band_inline(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#get_out_of_band_inline(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_out_of_band_inline(self)
    }

    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#set_no_check(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_no_check(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#get_no_check(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_no_check(self)
    }

    /// Set `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#set_linger(
        &self,
        mut linger: bool,
        mut length_secs: u32,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_linger(self, linger, length_secs)
    }

    /// Get `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#get_linger(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_linger(self)
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#set_reuse_port(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_reuse_port(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#get_reuse_port(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_reuse_port(self)
    }

    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
    pub fn r#get_accept_conn(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetAcceptConnResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_accept_conn(self)
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#set_bind_to_device(
        &self,
        mut value: &str,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_bind_to_device(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#get_bind_to_device(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_bind_to_device(self)
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    /// If `value` is 0, this clears the bound interface.
    pub fn r#set_bind_to_interface_index(
        &self,
        mut value: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_bind_to_interface_index(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    pub fn r#get_bind_to_interface_index(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_bind_to_interface_index(self)
    }

    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#set_timestamp(
        &self,
        mut value: TimestampOption,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_timestamp(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#get_timestamp(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_timestamp(self)
    }

    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be set independently in each domain.
    pub fn r#set_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        mut mark: &OptionalUint32,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_mark(self, domain, mark)
    }

    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be retrieved independently in each domain.
    pub fn r#get_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_mark(self, domain)
    }

    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
    pub fn r#get_cookie(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetCookieResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_cookie(self)
    }

    /// Sets the local address used for the socket.
    pub fn r#bind(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketBindResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#bind(self, addr)
    }

    /// Initiates a connection to a remote address.
    pub fn r#connect(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#connect(self, addr)
    }

    /// Clears connection information from this socket.
    pub fn r#disconnect(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketDisconnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#disconnect(self)
    }

    /// Retrieves the local socket address.
    pub fn r#get_sock_name(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetSockNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_sock_name(self)
    }

    /// Retrieves the remote socket address.
    pub fn r#get_peer_name(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetPeerNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_peer_name(self)
    }

    /// Shuts down part of the socket.
    pub fn r#shutdown(
        &self,
        mut mode: ShutdownMode,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketShutdownResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#shutdown(self, mode)
    }

    /// Set `SOL_IP` -> `IP_TOS`.
    pub fn r#set_ip_type_of_service(
        &self,
        mut value: u8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ip_type_of_service(self, value)
    }

    /// Get `SOL_IP` -> `IP_TOS`.
    pub fn r#get_ip_type_of_service(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ip_type_of_service(self)
    }

    /// Set `SOL_IP` -> `IP_TTL`.
    pub fn r#set_ip_ttl(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ip_ttl(self, value)
    }

    /// Get `SOL_IP` -> `IP_TTL`.
    pub fn r#get_ip_ttl(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ip_ttl(self)
    }

    /// Set `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#set_ip_packet_info(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ip_packet_info(self, value)
    }

    /// Get `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#get_ip_packet_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ip_packet_info(self)
    }

    /// Set `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#set_ip_receive_type_of_service(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ip_receive_type_of_service(self, value)
    }

    /// Get `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#get_ip_receive_type_of_service(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ip_receive_type_of_service(self)
    }

    /// Set `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#set_ip_receive_ttl(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ip_receive_ttl(self, value)
    }

    /// Get `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#get_ip_receive_ttl(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ip_receive_ttl(self)
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#set_ip_multicast_interface(
        &self,
        mut iface: u64,
        mut address: &fidl_fuchsia_net::Ipv4Address,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ip_multicast_interface(self, iface, address)
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#get_ip_multicast_interface(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ip_multicast_interface(self)
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#set_ip_multicast_ttl(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ip_multicast_ttl(self, value)
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#get_ip_multicast_ttl(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ip_multicast_ttl(self)
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#set_ip_multicast_loopback(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ip_multicast_loopback(self, value)
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#get_ip_multicast_loopback(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ip_multicast_loopback(self)
    }

    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
    pub fn r#add_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#add_ip_membership(self, membership)
    }

    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
    pub fn r#drop_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#drop_ip_membership(self, membership)
    }

    /// Set `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#set_ip_transparent(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ip_transparent(self, value)
    }

    /// Get `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#get_ip_transparent(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ip_transparent(self)
    }

    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#set_ip_receive_original_destination_address(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ip_receive_original_destination_address(self, value)
    }

    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#get_ip_receive_original_destination_address(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ip_receive_original_destination_address(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
    pub fn r#add_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#add_ipv6_membership(self, membership)
    }

    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
    pub fn r#drop_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#drop_ipv6_membership(self, membership)
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#set_ipv6_multicast_interface(
        &self,
        mut value: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ipv6_multicast_interface(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#get_ipv6_multicast_interface(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ipv6_multicast_interface(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#set_ipv6_unicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ipv6_unicast_hops(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#get_ipv6_unicast_hops(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ipv6_unicast_hops(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#set_ipv6_receive_hop_limit(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ipv6_receive_hop_limit(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#get_ipv6_receive_hop_limit(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ipv6_receive_hop_limit(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#set_ipv6_multicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ipv6_multicast_hops(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#get_ipv6_multicast_hops(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ipv6_multicast_hops(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#set_ipv6_multicast_loopback(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ipv6_multicast_loopback(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#get_ipv6_multicast_loopback(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ipv6_multicast_loopback(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#set_ipv6_only(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ipv6_only(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#get_ipv6_only(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ipv6_only(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#set_ipv6_receive_traffic_class(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ipv6_receive_traffic_class(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#get_ipv6_receive_traffic_class(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ipv6_receive_traffic_class(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
    pub fn r#set_ipv6_traffic_class(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ipv6_traffic_class(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
    pub fn r#get_ipv6_traffic_class(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ipv6_traffic_class(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#set_ipv6_receive_packet_info(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#set_ipv6_receive_packet_info(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#get_ipv6_receive_packet_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_ipv6_receive_packet_info(self)
    }

    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
    pub fn r#get_original_destination(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetOriginalDestinationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseNetworkSocketProxyInterface::r#get_original_destination(self)
    }
}

impl BaseNetworkSocketProxyInterface for BaseNetworkSocketProxy {
    fn r#clone(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type CloseResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#close(&self) -> Self::CloseResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5ac5d459ad7f657e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_unknown::CloseableCloseResult,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryResponseFut =
        fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#query(&self) -> Self::QueryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<u8>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl_fuchsia_unknown::QueryableQueryResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2658edee9decfc06,
            >(_buf?)?;
            Ok(_response.protocol)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1fd74ee8b9a4a876,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetReuseAddressRequest,
            BaseSocketSetReuseAddressResult,
        >(
            (value,),
            0x1fd74ee8b9a4a876,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetReuseAddressResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x67b7206b8d1bc0a5,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReuseAddressResult>(
                (),
                0x67b7206b8d1bc0a5,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetErrorResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetErrorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_error(&self) -> Self::GetErrorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5aad39b33e5f6ebb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetErrorResult>(
            (),
            0x5aad39b33e5f6ebb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6023e081ce3cd947,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetBroadcastRequest, BaseSocketSetBroadcastResult>(
                (value,),
                0x6023e081ce3cd947,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetBroadcastResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x68796fc556f9780d,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBroadcastResult>(
                (),
                0x68796fc556f9780d,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x756eac32d73a7a70,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetSendBufferRequest, BaseSocketSetSendBufferResult>(
                (value_bytes,),
                0x756eac32d73a7a70,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetSendBufferResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x78a52fd9c7b2410b,
            >(_buf?)?;
            Ok(_response.map(|x| x.value_bytes))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetSendBufferResult>(
                (),
                0x78a52fd9c7b2410b,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6b0cf2f1919c7001,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetReceiveBufferRequest,
            BaseSocketSetReceiveBufferResult,
        >(
            (value_bytes,),
            0x6b0cf2f1919c7001,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetReceiveBufferResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x14c1a4b64f709e5c,
            >(_buf?)?;
            Ok(_response.map(|x| x.value_bytes))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseSocketGetReceiveBufferResult,
        >(
            (),
            0x14c1a4b64f709e5c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x572df8f0b920d2c7,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetKeepAliveRequest, BaseSocketSetKeepAliveResult>(
                (value,),
                0x572df8f0b920d2c7,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetKeepAliveResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2dd29d3215f2c9d2,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetKeepAliveResult>(
                (),
                0x2dd29d3215f2c9d2,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3ecb49968bee439,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetOutOfBandInlineRequest,
            BaseSocketSetOutOfBandInlineResult,
        >(
            (value,),
            0x3ecb49968bee439,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetOutOfBandInlineResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x348c1ab3aeca1745,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseSocketGetOutOfBandInlineResult,
        >(
            (),
            0x348c1ab3aeca1745,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6bbf00c53a4c78c2,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetNoCheckRequest, BaseSocketSetNoCheckResult>(
                (value,),
                0x6bbf00c53a4c78c2,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetNoCheckResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2cd4249286417694,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetNoCheckResult>(
                (),
                0x2cd4249286417694,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetLingerResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x45386351246e998e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<BaseSocketSetLingerRequest, BaseSocketSetLingerResult>(
            (linger, length_secs),
            0x45386351246e998e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetLingerResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_linger(&self) -> Self::GetLingerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetLingerResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x48eb20fc5ccb0e45,
            >(_buf?)?;
            Ok(_response.map(|x| (x.linger, x.length_secs)))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetLingerResult>(
                (),
                0x48eb20fc5ccb0e45,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetReusePortResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x24dd3e5cb36d9ccb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetReusePortRequest, BaseSocketSetReusePortResult>(
                (value,),
                0x24dd3e5cb36d9ccb,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetReusePortResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetReusePortResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7a112c1ab54ff828,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReusePortResult>(
                (),
                0x7a112c1ab54ff828,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetAcceptConnResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetAcceptConnResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x67ce6db6c2ec8966,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetAcceptConnResult>(
                (),
                0x67ce6db6c2ec8966,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2118b483f28aafc4,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetBindToDeviceRequest,
            BaseSocketSetBindToDeviceResult,
        >(
            (value,),
            0x2118b483f28aafc4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetBindToDeviceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ab1fbf0ef7906c8,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBindToDeviceResult>(
                (),
                0x1ab1fbf0ef7906c8,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_bind_to_interface_index(
        &self,
        mut value: u64,
    ) -> Self::SetBindToInterfaceIndexResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6e387a0def00821,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetBindToInterfaceIndexRequest,
            BaseSocketSetBindToInterfaceIndexResult,
        >(
            (value,),
            0x6e387a0def00821,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetBindToInterfaceIndexResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x59c31dd3e3078295,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseSocketGetBindToInterfaceIndexResult,
        >(
            (),
            0x59c31dd3e3078295,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetTimestampResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_timestamp(&self, mut value: TimestampOption) -> Self::SetTimestampResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x285d6516c263d839,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetTimestampRequest, BaseSocketSetTimestampResult>(
                (value,),
                0x285d6516c263d839,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetTimestampResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetTimestampResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x49f2fffbbcc2bd27,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetTimestampResult>(
                (),
                0x49f2fffbbcc2bd27,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetMarkResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        mut mark: &OptionalUint32,
    ) -> Self::SetMarkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6ead6de09f653236,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<BaseSocketSetMarkRequest, BaseSocketSetMarkResult>(
            (domain, mark),
            0x6ead6de09f653236,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetMarkResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x57a2752c61d93d47,
            >(_buf?)?;
            Ok(_response.map(|x| x.mark))
        }
        self.client.send_query_and_decode::<BaseSocketGetMarkRequest, BaseSocketGetMarkResult>(
            (domain,),
            0x57a2752c61d93d47,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetCookieResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetCookieResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_cookie(&self) -> Self::GetCookieResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetCookieResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetCookieResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2c2f47fd8f924e52,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetCookieResult>(
                (),
                0x2c2f47fd8f924e52,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type BindResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketBindResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#bind(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4bc6400ae92125d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseNetworkSocketBindRequest, BaseNetworkSocketBindResult>(
                (addr,),
                0x4bc6400ae92125d,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ConnectResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5f05f19bfdd38871,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketConnectRequest,
            BaseNetworkSocketConnectResult,
        >(
            (addr,),
            0x5f05f19bfdd38871,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DisconnectResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketDisconnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#disconnect(&self) -> Self::DisconnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x74e63b91f7b29b2,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketDisconnectResult,
        >(
            (),
            0x74e63b91f7b29b2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetSockNameResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetSockNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetSockNameResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x475f23f84a1a4f85,
            >(_buf?)?;
            Ok(_response.map(|x| x.addr))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetSockNameResult,
        >(
            (),
            0x475f23f84a1a4f85,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetPeerNameResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetPeerNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetPeerNameResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ffecf4bd5b6432e,
            >(_buf?)?;
            Ok(_response.map(|x| x.addr))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetPeerNameResult,
        >(
            (),
            0x1ffecf4bd5b6432e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ShutdownResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketShutdownResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#shutdown(&self, mut mode: ShutdownMode) -> Self::ShutdownResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x247f38b6db68c336,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketShutdownRequest,
            BaseNetworkSocketShutdownResult,
        >(
            (mode,),
            0x247f38b6db68c336,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_type_of_service(&self, mut value: u8) -> Self::SetIpTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x995c600475b6d46,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpTypeOfServiceRequest,
            BaseNetworkSocketSetIpTypeOfServiceResult,
        >(
            (value,),
            0x995c600475b6d46,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpTypeOfServiceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3814a04259f75fcb,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpTypeOfServiceResult,
        >(
            (),
            0x3814a04259f75fcb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_ttl(&self, mut value: &OptionalUint8) -> Self::SetIpTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x29e2424b433ae1ef,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpTtlRequest,
            BaseNetworkSocketSetIpTtlResult,
        >(
            (value,),
            0x29e2424b433ae1ef,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpTtlResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x47e47fa1f24da471,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseNetworkSocketGetIpTtlResult>(
                (),
                0x47e47fa1f24da471,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_packet_info(&self, mut value: bool) -> Self::SetIpPacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x392d16bee20c0e16,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpPacketInfoRequest,
            BaseNetworkSocketSetIpPacketInfoResult,
        >(
            (value,),
            0x392d16bee20c0e16,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpPacketInfoResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x54b505f242280740,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpPacketInfoResult,
        >(
            (),
            0x54b505f242280740,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_receive_type_of_service(
        &self,
        mut value: bool,
    ) -> Self::SetIpReceiveTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6c4f6714995f84ef,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
            BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
        >(
            (value,),
            0x6c4f6714995f84ef,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4158ba7dc2795960,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
        >(
            (),
            0x4158ba7dc2795960,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_receive_ttl(&self, mut value: bool) -> Self::SetIpReceiveTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x46f15be0ce0ab82b,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpReceiveTtlRequest,
            BaseNetworkSocketSetIpReceiveTtlResult,
        >(
            (value,),
            0x46f15be0ce0ab82b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpReceiveTtlResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x678ddd5a5dfa2eb5,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpReceiveTtlResult,
        >(
            (),
            0x678ddd5a5dfa2eb5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_multicast_interface(
        &self,
        mut iface: u64,
        mut address: &fidl_fuchsia_net::Ipv4Address,
    ) -> Self::SetIpMulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x752fbfa9b12befe,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpMulticastInterfaceRequest,
            BaseNetworkSocketSetIpMulticastInterfaceResult,
        >(
            (iface, address,),
            0x752fbfa9b12befe,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpMulticastInterfaceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x320bd14c4df046c4,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpMulticastInterfaceResult,
        >(
            (),
            0x320bd14c4df046c4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_multicast_ttl(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpMulticastTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x63134d53772916a1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpMulticastTtlRequest,
            BaseNetworkSocketSetIpMulticastTtlResult,
        >(
            (value,),
            0x63134d53772916a1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpMulticastTtlResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4665cd378f39e1a,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpMulticastTtlResult,
        >(
            (),
            0x4665cd378f39e1a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_multicast_loopback(
        &self,
        mut value: bool,
    ) -> Self::SetIpMulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x20c55c11f00943ea,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpMulticastLoopbackRequest,
            BaseNetworkSocketSetIpMulticastLoopbackResult,
        >(
            (value,),
            0x20c55c11f00943ea,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpMulticastLoopbackResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3b6b26ff558298f2,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpMulticastLoopbackResult,
        >(
            (),
            0x3b6b26ff558298f2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddIpMembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> Self::AddIpMembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x76bc7df115a3b4d0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketAddIpMembershipRequest,
            BaseNetworkSocketAddIpMembershipResult,
        >(
            (membership,),
            0x76bc7df115a3b4d0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DropIpMembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#drop_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> Self::DropIpMembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2888f3099188d03,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketDropIpMembershipRequest,
            BaseNetworkSocketDropIpMembershipResult,
        >(
            (membership,),
            0x2888f3099188d03,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpTransparentResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_transparent(&self, mut value: bool) -> Self::SetIpTransparentResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ae532b0c066e3a0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpTransparentRequest,
            BaseNetworkSocketSetIpTransparentResult,
        >(
            (value,),
            0x1ae532b0c066e3a0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpTransparentResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpTransparentResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x51d43695962ebfb5,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpTransparentResult,
        >(
            (),
            0x51d43695962ebfb5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_receive_original_destination_address(
        &self,
        mut value: bool,
    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4722b4ce52f7840,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
        >(
            (value,),
            0x4722b4ce52f7840,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_receive_original_destination_address(
        &self,
    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2a0e7dc5d6bfdfe9,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
        >(
            (),
            0x2a0e7dc5d6bfdfe9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> Self::AddIpv6MembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7c94727acb4ea4b3,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketAddIpv6MembershipRequest,
            BaseNetworkSocketAddIpv6MembershipResult,
        >(
            (membership,),
            0x7c94727acb4ea4b3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DropIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#drop_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> Self::DropIpv6MembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x42104c70ccaba304,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketDropIpv6MembershipRequest,
            BaseNetworkSocketDropIpv6MembershipResult,
        >(
            (membership,),
            0x42104c70ccaba304,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_multicast_interface(
        &self,
        mut value: u64,
    ) -> Self::SetIpv6MulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x135f76db3774ab3b,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
            BaseNetworkSocketSetIpv6MulticastInterfaceResult,
        >(
            (value,),
            0x135f76db3774ab3b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1f26fcdd348f1882,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6MulticastInterfaceResult,
        >(
            (),
            0x1f26fcdd348f1882,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_unicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpv6UnicastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x157d51e98f462859,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6UnicastHopsRequest,
            BaseNetworkSocketSetIpv6UnicastHopsResult,
        >(
            (value,),
            0x157d51e98f462859,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6UnicastHopsResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x21f4641cad8bd8d2,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6UnicastHopsResult,
        >(
            (),
            0x21f4641cad8bd8d2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_receive_hop_limit(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6ReceiveHopLimitResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5c24808ed2e84a1e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
            BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
        >(
            (value,),
            0x5c24808ed2e84a1e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x341e06689885b4c0,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
        >(
            (),
            0x341e06689885b4c0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_multicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpv6MulticastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x25b9cd4d181f82c1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6MulticastHopsRequest,
            BaseNetworkSocketSetIpv6MulticastHopsResult,
        >(
            (value,),
            0x25b9cd4d181f82c1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6MulticastHopsResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x52916948a365012a,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6MulticastHopsResult,
        >(
            (),
            0x52916948a365012a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_multicast_loopback(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6MulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x55701c409ff41b40,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
            BaseNetworkSocketSetIpv6MulticastLoopbackResult,
        >(
            (value,),
            0x55701c409ff41b40,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4415b701fde319c3,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6MulticastLoopbackResult,
        >(
            (),
            0x4415b701fde319c3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_only(&self, mut value: bool) -> Self::SetIpv6OnlyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4873f1364758cbba,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6OnlyRequest,
            BaseNetworkSocketSetIpv6OnlyResult,
        >(
            (value,),
            0x4873f1364758cbba,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6OnlyResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4aa3340a1a26b89c,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6OnlyResult,
        >(
            (),
            0x4aa3340a1a26b89c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_receive_traffic_class(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x58f07c8788d099a0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
            BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
        >(
            (value,),
            0x58f07c8788d099a0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2e334df1da553ffa,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
        >(
            (),
            0x2e334df1da553ffa,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_traffic_class(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpv6TrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6af077800c5a0b4f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6TrafficClassRequest,
            BaseNetworkSocketSetIpv6TrafficClassResult,
        >(
            (value,),
            0x6af077800c5a0b4f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6TrafficClassResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6baf6eed8fc2f04,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6TrafficClassResult,
        >(
            (),
            0x6baf6eed8fc2f04,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_receive_packet_info(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6ReceivePacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x19259775b1a92768,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
            BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
        >(
            (value,),
            0x19259775b1a92768,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7acd4a2775baec75,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
        >(
            (),
            0x7acd4a2775baec75,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetOriginalDestinationResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetOriginalDestinationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetOriginalDestinationResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x38bf28f0dafdbac0,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetOriginalDestinationResult,
        >(
            (),
            0x38bf28f0dafdbac0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct BaseNetworkSocketEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for BaseNetworkSocketEventStream {}

impl futures::stream::FusedStream for BaseNetworkSocketEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for BaseNetworkSocketEventStream {
    type Item = Result<BaseNetworkSocketEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(BaseNetworkSocketEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum BaseNetworkSocketEvent {}

impl BaseNetworkSocketEvent {
    /// Decodes a message buffer as a [`BaseNetworkSocketEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<BaseNetworkSocketEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <BaseNetworkSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.posix.socket/BaseNetworkSocket.
pub struct BaseNetworkSocketRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for BaseNetworkSocketRequestStream {}

impl futures::stream::FusedStream for BaseNetworkSocketRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for BaseNetworkSocketRequestStream {
    type Protocol = BaseNetworkSocketMarker;
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        BaseNetworkSocketControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for BaseNetworkSocketRequestStream {
    type Item = Result<BaseNetworkSocketRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled BaseNetworkSocketRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x20d8a7aba2168a79 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl_fuchsia_unknown::CloneableCloneRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::Clone { request: req.request, control_handle })
                    }
                    0x5ac5d459ad7f657e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::Close {
                            responder: BaseNetworkSocketCloseResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2658edee9decfc06 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::Query {
                            responder: BaseNetworkSocketQueryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1fd74ee8b9a4a876 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetReuseAddressRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetReuseAddress {
                            value: req.value,

                            responder: BaseNetworkSocketSetReuseAddressResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x67b7206b8d1bc0a5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetReuseAddress {
                            responder: BaseNetworkSocketGetReuseAddressResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5aad39b33e5f6ebb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetError {
                            responder: BaseNetworkSocketGetErrorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6023e081ce3cd947 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetBroadcastRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetBroadcast {
                            value: req.value,

                            responder: BaseNetworkSocketSetBroadcastResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x68796fc556f9780d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetBroadcast {
                            responder: BaseNetworkSocketGetBroadcastResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x756eac32d73a7a70 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetSendBufferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetSendBuffer {
                            value_bytes: req.value_bytes,

                            responder: BaseNetworkSocketSetSendBufferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x78a52fd9c7b2410b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetSendBuffer {
                            responder: BaseNetworkSocketGetSendBufferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6b0cf2f1919c7001 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetReceiveBufferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetReceiveBuffer {
                            value_bytes: req.value_bytes,

                            responder: BaseNetworkSocketSetReceiveBufferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x14c1a4b64f709e5c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetReceiveBuffer {
                            responder: BaseNetworkSocketGetReceiveBufferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x572df8f0b920d2c7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetKeepAliveRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetKeepAlive {
                            value: req.value,

                            responder: BaseNetworkSocketSetKeepAliveResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2dd29d3215f2c9d2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetKeepAlive {
                            responder: BaseNetworkSocketGetKeepAliveResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3ecb49968bee439 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetOutOfBandInlineRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetOutOfBandInline {
                            value: req.value,

                            responder: BaseNetworkSocketSetOutOfBandInlineResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x348c1ab3aeca1745 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetOutOfBandInline {
                            responder: BaseNetworkSocketGetOutOfBandInlineResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6bbf00c53a4c78c2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetNoCheckRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetNoCheck {
                            value: req.value,

                            responder: BaseNetworkSocketSetNoCheckResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2cd4249286417694 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetNoCheck {
                            responder: BaseNetworkSocketGetNoCheckResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x45386351246e998e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetLingerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetLinger {
                            linger: req.linger,
                            length_secs: req.length_secs,

                            responder: BaseNetworkSocketSetLingerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x48eb20fc5ccb0e45 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetLinger {
                            responder: BaseNetworkSocketGetLingerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x24dd3e5cb36d9ccb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetReusePortRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetReusePort {
                            value: req.value,

                            responder: BaseNetworkSocketSetReusePortResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7a112c1ab54ff828 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetReusePort {
                            responder: BaseNetworkSocketGetReusePortResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x67ce6db6c2ec8966 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetAcceptConn {
                            responder: BaseNetworkSocketGetAcceptConnResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2118b483f28aafc4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetBindToDeviceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetBindToDevice {
                            value: req.value,

                            responder: BaseNetworkSocketSetBindToDeviceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1ab1fbf0ef7906c8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetBindToDevice {
                            responder: BaseNetworkSocketGetBindToDeviceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6e387a0def00821 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetBindToInterfaceIndexRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetBindToInterfaceIndex {
                            value: req.value,

                            responder: BaseNetworkSocketSetBindToInterfaceIndexResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x59c31dd3e3078295 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetBindToInterfaceIndex {
                            responder: BaseNetworkSocketGetBindToInterfaceIndexResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x285d6516c263d839 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetTimestampRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetTimestamp {
                            value: req.value,

                            responder: BaseNetworkSocketSetTimestampResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x49f2fffbbcc2bd27 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetTimestamp {
                            responder: BaseNetworkSocketGetTimestampResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6ead6de09f653236 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetMarkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetMark {
                            domain: req.domain,
                            mark: req.mark,

                            responder: BaseNetworkSocketSetMarkResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x57a2752c61d93d47 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketGetMarkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetMark {
                            domain: req.domain,

                            responder: BaseNetworkSocketGetMarkResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2c2f47fd8f924e52 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetCookie {
                            responder: BaseNetworkSocketGetCookieResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4bc6400ae92125d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketBindRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketBindRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::Bind {
                            addr: req.addr,

                            responder: BaseNetworkSocketBindResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5f05f19bfdd38871 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::Connect {
                            addr: req.addr,

                            responder: BaseNetworkSocketConnectResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x74e63b91f7b29b2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::Disconnect {
                            responder: BaseNetworkSocketDisconnectResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x475f23f84a1a4f85 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetSockName {
                            responder: BaseNetworkSocketGetSockNameResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1ffecf4bd5b6432e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetPeerName {
                            responder: BaseNetworkSocketGetPeerNameResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x247f38b6db68c336 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketShutdownRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketShutdownRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::Shutdown {
                            mode: req.mode,

                            responder: BaseNetworkSocketShutdownResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x995c600475b6d46 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpTypeOfServiceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpTypeOfService {
                            value: req.value,

                            responder: BaseNetworkSocketSetIpTypeOfServiceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3814a04259f75fcb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpTypeOfService {
                            responder: BaseNetworkSocketGetIpTypeOfServiceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x29e2424b433ae1ef => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpTtlRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTtlRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpTtl {
                            value: req.value,

                            responder: BaseNetworkSocketSetIpTtlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x47e47fa1f24da471 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpTtl {
                            responder: BaseNetworkSocketGetIpTtlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x392d16bee20c0e16 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpPacketInfoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpPacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpPacketInfo {
                            value: req.value,

                            responder: BaseNetworkSocketSetIpPacketInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x54b505f242280740 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpPacketInfo {
                            responder: BaseNetworkSocketGetIpPacketInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6c4f6714995f84ef => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpReceiveTypeOfService {
                            value: req.value,

                            responder: BaseNetworkSocketSetIpReceiveTypeOfServiceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4158ba7dc2795960 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpReceiveTypeOfService {
                            responder: BaseNetworkSocketGetIpReceiveTypeOfServiceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x46f15be0ce0ab82b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpReceiveTtlRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTtlRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpReceiveTtl {
                            value: req.value,

                            responder: BaseNetworkSocketSetIpReceiveTtlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x678ddd5a5dfa2eb5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpReceiveTtl {
                            responder: BaseNetworkSocketGetIpReceiveTtlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x752fbfa9b12befe => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpMulticastInterfaceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpMulticastInterface {
                            iface: req.iface,
                            address: req.address,

                            responder: BaseNetworkSocketSetIpMulticastInterfaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x320bd14c4df046c4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpMulticastInterface {
                            responder: BaseNetworkSocketGetIpMulticastInterfaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x63134d53772916a1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpMulticastTtlRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastTtlRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpMulticastTtl {
                            value: req.value,

                            responder: BaseNetworkSocketSetIpMulticastTtlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4665cd378f39e1a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpMulticastTtl {
                            responder: BaseNetworkSocketGetIpMulticastTtlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x20c55c11f00943ea => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpMulticastLoopbackRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpMulticastLoopback {
                            value: req.value,

                            responder: BaseNetworkSocketSetIpMulticastLoopbackResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3b6b26ff558298f2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpMulticastLoopback {
                            responder: BaseNetworkSocketGetIpMulticastLoopbackResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x76bc7df115a3b4d0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketAddIpMembershipRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::AddIpMembership {
                            membership: req.membership,

                            responder: BaseNetworkSocketAddIpMembershipResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2888f3099188d03 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketDropIpMembershipRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::DropIpMembership {
                            membership: req.membership,

                            responder: BaseNetworkSocketDropIpMembershipResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1ae532b0c066e3a0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpTransparentRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTransparentRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpTransparent {
                            value: req.value,

                            responder: BaseNetworkSocketSetIpTransparentResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x51d43695962ebfb5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpTransparent {
                            responder: BaseNetworkSocketGetIpTransparentResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4722b4ce52f7840 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpReceiveOriginalDestinationAddress {
                            value: req.value,

                            responder:
                                BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder {
                                    control_handle: std::mem::ManuallyDrop::new(control_handle),
                                    tx_id: header.tx_id,
                                },
                        })
                    }
                    0x2a0e7dc5d6bfdfe9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpReceiveOriginalDestinationAddress {
                            responder:
                                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder {
                                    control_handle: std::mem::ManuallyDrop::new(control_handle),
                                    tx_id: header.tx_id,
                                },
                        })
                    }
                    0x7c94727acb4ea4b3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketAddIpv6MembershipRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::AddIpv6Membership {
                            membership: req.membership,

                            responder: BaseNetworkSocketAddIpv6MembershipResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x42104c70ccaba304 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketDropIpv6MembershipRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::DropIpv6Membership {
                            membership: req.membership,

                            responder: BaseNetworkSocketDropIpv6MembershipResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x135f76db3774ab3b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpv6MulticastInterface {
                            value: req.value,

                            responder: BaseNetworkSocketSetIpv6MulticastInterfaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1f26fcdd348f1882 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpv6MulticastInterface {
                            responder: BaseNetworkSocketGetIpv6MulticastInterfaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x157d51e98f462859 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6UnicastHopsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6UnicastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpv6UnicastHops {
                            value: req.value,

                            responder: BaseNetworkSocketSetIpv6UnicastHopsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x21f4641cad8bd8d2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpv6UnicastHops {
                            responder: BaseNetworkSocketGetIpv6UnicastHopsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5c24808ed2e84a1e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveHopLimitRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpv6ReceiveHopLimit {
                            value: req.value,

                            responder: BaseNetworkSocketSetIpv6ReceiveHopLimitResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x341e06689885b4c0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpv6ReceiveHopLimit {
                            responder: BaseNetworkSocketGetIpv6ReceiveHopLimitResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x25b9cd4d181f82c1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6MulticastHopsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpv6MulticastHops {
                            value: req.value,

                            responder: BaseNetworkSocketSetIpv6MulticastHopsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x52916948a365012a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpv6MulticastHops {
                            responder: BaseNetworkSocketGetIpv6MulticastHopsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x55701c409ff41b40 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpv6MulticastLoopback {
                            value: req.value,

                            responder: BaseNetworkSocketSetIpv6MulticastLoopbackResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4415b701fde319c3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpv6MulticastLoopback {
                            responder: BaseNetworkSocketGetIpv6MulticastLoopbackResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4873f1364758cbba => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6OnlyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6OnlyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpv6Only {
                            value: req.value,

                            responder: BaseNetworkSocketSetIpv6OnlyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4aa3340a1a26b89c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpv6Only {
                            responder: BaseNetworkSocketGetIpv6OnlyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x58f07c8788d099a0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpv6ReceiveTrafficClass {
                            value: req.value,

                            responder: BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2e334df1da553ffa => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpv6ReceiveTrafficClass {
                            responder: BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6af077800c5a0b4f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6TrafficClassRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6TrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpv6TrafficClass {
                            value: req.value,

                            responder: BaseNetworkSocketSetIpv6TrafficClassResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6baf6eed8fc2f04 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpv6TrafficClass {
                            responder: BaseNetworkSocketGetIpv6TrafficClassResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x19259775b1a92768 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceivePacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::SetIpv6ReceivePacketInfo {
                            value: req.value,

                            responder: BaseNetworkSocketSetIpv6ReceivePacketInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7acd4a2775baec75 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetIpv6ReceivePacketInfo {
                            responder: BaseNetworkSocketGetIpv6ReceivePacketInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x38bf28f0dafdbac0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseNetworkSocketRequest::GetOriginalDestination {
                            responder: BaseNetworkSocketGetOriginalDestinationResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <BaseNetworkSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A network socket.
#[derive(Debug)]
pub enum BaseNetworkSocketRequest {
    Clone {
        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
        control_handle: BaseNetworkSocketControlHandle,
    },
    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    Close {
        responder: BaseNetworkSocketCloseResponder,
    },
    Query {
        responder: BaseNetworkSocketQueryResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
    SetReuseAddress {
        value: bool,
        responder: BaseNetworkSocketSetReuseAddressResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
    GetReuseAddress {
        responder: BaseNetworkSocketGetReuseAddressResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_ERROR`.
    /// Returns the last error if there is an error set on the socket.
    GetError {
        responder: BaseNetworkSocketGetErrorResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
    SetBroadcast {
        value: bool,
        responder: BaseNetworkSocketSetBroadcastResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
    GetBroadcast {
        responder: BaseNetworkSocketGetBroadcastResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
    SetSendBuffer {
        value_bytes: u64,
        responder: BaseNetworkSocketSetSendBufferResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
    GetSendBuffer {
        responder: BaseNetworkSocketGetSendBufferResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
    SetReceiveBuffer {
        value_bytes: u64,
        responder: BaseNetworkSocketSetReceiveBufferResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
    GetReceiveBuffer {
        responder: BaseNetworkSocketGetReceiveBufferResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
    SetKeepAlive {
        value: bool,
        responder: BaseNetworkSocketSetKeepAliveResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
    GetKeepAlive {
        responder: BaseNetworkSocketGetKeepAliveResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
    SetOutOfBandInline {
        value: bool,
        responder: BaseNetworkSocketSetOutOfBandInlineResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
    GetOutOfBandInline {
        responder: BaseNetworkSocketGetOutOfBandInlineResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
    SetNoCheck {
        value: bool,
        responder: BaseNetworkSocketSetNoCheckResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
    GetNoCheck {
        responder: BaseNetworkSocketGetNoCheckResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_LINGER`.
    SetLinger {
        linger: bool,
        length_secs: u32,
        responder: BaseNetworkSocketSetLingerResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_LINGER`.
    GetLinger {
        responder: BaseNetworkSocketGetLingerResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
    SetReusePort {
        value: bool,
        responder: BaseNetworkSocketSetReusePortResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
    GetReusePort {
        responder: BaseNetworkSocketGetReusePortResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
    GetAcceptConn {
        responder: BaseNetworkSocketGetAcceptConnResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    SetBindToDevice {
        value: String,
        responder: BaseNetworkSocketSetBindToDeviceResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    GetBindToDevice {
        responder: BaseNetworkSocketGetBindToDeviceResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    /// If `value` is 0, this clears the bound interface.
    SetBindToInterfaceIndex {
        value: u64,
        responder: BaseNetworkSocketSetBindToInterfaceIndexResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    GetBindToInterfaceIndex {
        responder: BaseNetworkSocketGetBindToInterfaceIndexResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    SetTimestamp {
        value: TimestampOption,
        responder: BaseNetworkSocketSetTimestampResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    GetTimestamp {
        responder: BaseNetworkSocketGetTimestampResponder,
    },
    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be set independently in each domain.
    SetMark {
        domain: fidl_fuchsia_net::MarkDomain,
        mark: OptionalUint32,
        responder: BaseNetworkSocketSetMarkResponder,
    },
    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be retrieved independently in each domain.
    GetMark {
        domain: fidl_fuchsia_net::MarkDomain,
        responder: BaseNetworkSocketGetMarkResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
    GetCookie {
        responder: BaseNetworkSocketGetCookieResponder,
    },
    /// Sets the local address used for the socket.
    Bind {
        addr: fidl_fuchsia_net::SocketAddress,
        responder: BaseNetworkSocketBindResponder,
    },
    /// Initiates a connection to a remote address.
    Connect {
        addr: fidl_fuchsia_net::SocketAddress,
        responder: BaseNetworkSocketConnectResponder,
    },
    /// Clears connection information from this socket.
    Disconnect {
        responder: BaseNetworkSocketDisconnectResponder,
    },
    /// Retrieves the local socket address.
    GetSockName {
        responder: BaseNetworkSocketGetSockNameResponder,
    },
    /// Retrieves the remote socket address.
    GetPeerName {
        responder: BaseNetworkSocketGetPeerNameResponder,
    },
    /// Shuts down part of the socket.
    Shutdown {
        mode: ShutdownMode,
        responder: BaseNetworkSocketShutdownResponder,
    },
    /// Set `SOL_IP` -> `IP_TOS`.
    SetIpTypeOfService {
        value: u8,
        responder: BaseNetworkSocketSetIpTypeOfServiceResponder,
    },
    /// Get `SOL_IP` -> `IP_TOS`.
    GetIpTypeOfService {
        responder: BaseNetworkSocketGetIpTypeOfServiceResponder,
    },
    /// Set `SOL_IP` -> `IP_TTL`.
    SetIpTtl {
        value: OptionalUint8,
        responder: BaseNetworkSocketSetIpTtlResponder,
    },
    /// Get `SOL_IP` -> `IP_TTL`.
    GetIpTtl {
        responder: BaseNetworkSocketGetIpTtlResponder,
    },
    /// Set `SOL_IP` -> `IP_PKTINFO`.
    SetIpPacketInfo {
        value: bool,
        responder: BaseNetworkSocketSetIpPacketInfoResponder,
    },
    /// Get `SOL_IP` -> `IP_PKTINFO`.
    GetIpPacketInfo {
        responder: BaseNetworkSocketGetIpPacketInfoResponder,
    },
    /// Set `SOL_IP` -> `IP_RECVTOS`.
    SetIpReceiveTypeOfService {
        value: bool,
        responder: BaseNetworkSocketSetIpReceiveTypeOfServiceResponder,
    },
    /// Get `SOL_IP` -> `IP_RECVTOS`.
    GetIpReceiveTypeOfService {
        responder: BaseNetworkSocketGetIpReceiveTypeOfServiceResponder,
    },
    /// Set `SOL_IP` -> `IP_RECVTTL`.
    SetIpReceiveTtl {
        value: bool,
        responder: BaseNetworkSocketSetIpReceiveTtlResponder,
    },
    /// Get `SOL_IP` -> `IP_RECVTTL`.
    GetIpReceiveTtl {
        responder: BaseNetworkSocketGetIpReceiveTtlResponder,
    },
    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
    SetIpMulticastInterface {
        iface: u64,
        address: fidl_fuchsia_net::Ipv4Address,
        responder: BaseNetworkSocketSetIpMulticastInterfaceResponder,
    },
    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
    GetIpMulticastInterface {
        responder: BaseNetworkSocketGetIpMulticastInterfaceResponder,
    },
    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
    SetIpMulticastTtl {
        value: OptionalUint8,
        responder: BaseNetworkSocketSetIpMulticastTtlResponder,
    },
    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
    GetIpMulticastTtl {
        responder: BaseNetworkSocketGetIpMulticastTtlResponder,
    },
    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
    SetIpMulticastLoopback {
        value: bool,
        responder: BaseNetworkSocketSetIpMulticastLoopbackResponder,
    },
    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
    GetIpMulticastLoopback {
        responder: BaseNetworkSocketGetIpMulticastLoopbackResponder,
    },
    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
    AddIpMembership {
        membership: IpMulticastMembership,
        responder: BaseNetworkSocketAddIpMembershipResponder,
    },
    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
    DropIpMembership {
        membership: IpMulticastMembership,
        responder: BaseNetworkSocketDropIpMembershipResponder,
    },
    /// Set `SOL_IP` -> `IP_TRANSPARENT`
    SetIpTransparent {
        value: bool,
        responder: BaseNetworkSocketSetIpTransparentResponder,
    },
    /// Get `SOL_IP` -> `IP_TRANSPARENT`
    GetIpTransparent {
        responder: BaseNetworkSocketGetIpTransparentResponder,
    },
    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
    SetIpReceiveOriginalDestinationAddress {
        value: bool,
        responder: BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder,
    },
    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
    GetIpReceiveOriginalDestinationAddress {
        responder: BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
    AddIpv6Membership {
        membership: Ipv6MulticastMembership,
        responder: BaseNetworkSocketAddIpv6MembershipResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
    DropIpv6Membership {
        membership: Ipv6MulticastMembership,
        responder: BaseNetworkSocketDropIpv6MembershipResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    SetIpv6MulticastInterface {
        value: u64,
        responder: BaseNetworkSocketSetIpv6MulticastInterfaceResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    GetIpv6MulticastInterface {
        responder: BaseNetworkSocketGetIpv6MulticastInterfaceResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    SetIpv6UnicastHops {
        value: OptionalUint8,
        responder: BaseNetworkSocketSetIpv6UnicastHopsResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    GetIpv6UnicastHops {
        responder: BaseNetworkSocketGetIpv6UnicastHopsResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    SetIpv6ReceiveHopLimit {
        value: bool,
        responder: BaseNetworkSocketSetIpv6ReceiveHopLimitResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    GetIpv6ReceiveHopLimit {
        responder: BaseNetworkSocketGetIpv6ReceiveHopLimitResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    SetIpv6MulticastHops {
        value: OptionalUint8,
        responder: BaseNetworkSocketSetIpv6MulticastHopsResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    GetIpv6MulticastHops {
        responder: BaseNetworkSocketGetIpv6MulticastHopsResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    SetIpv6MulticastLoopback {
        value: bool,
        responder: BaseNetworkSocketSetIpv6MulticastLoopbackResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    GetIpv6MulticastLoopback {
        responder: BaseNetworkSocketGetIpv6MulticastLoopbackResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
    SetIpv6Only {
        value: bool,
        responder: BaseNetworkSocketSetIpv6OnlyResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
    GetIpv6Only {
        responder: BaseNetworkSocketGetIpv6OnlyResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    SetIpv6ReceiveTrafficClass {
        value: bool,
        responder: BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    GetIpv6ReceiveTrafficClass {
        responder: BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
    SetIpv6TrafficClass {
        value: OptionalUint8,
        responder: BaseNetworkSocketSetIpv6TrafficClassResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
    GetIpv6TrafficClass {
        responder: BaseNetworkSocketGetIpv6TrafficClassResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    SetIpv6ReceivePacketInfo {
        value: bool,
        responder: BaseNetworkSocketSetIpv6ReceivePacketInfoResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    GetIpv6ReceivePacketInfo {
        responder: BaseNetworkSocketGetIpv6ReceivePacketInfoResponder,
    },
    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
    GetOriginalDestination {
        responder: BaseNetworkSocketGetOriginalDestinationResponder,
    },
}

impl BaseNetworkSocketRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_clone(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
        BaseNetworkSocketControlHandle,
    )> {
        if let BaseNetworkSocketRequest::Clone { request, control_handle } = self {
            Some((request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_close(self) -> Option<(BaseNetworkSocketCloseResponder)> {
        if let BaseNetworkSocketRequest::Close { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query(self) -> Option<(BaseNetworkSocketQueryResponder)> {
        if let BaseNetworkSocketRequest::Query { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_reuse_address(
        self,
    ) -> Option<(bool, BaseNetworkSocketSetReuseAddressResponder)> {
        if let BaseNetworkSocketRequest::SetReuseAddress { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_reuse_address(self) -> Option<(BaseNetworkSocketGetReuseAddressResponder)> {
        if let BaseNetworkSocketRequest::GetReuseAddress { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_error(self) -> Option<(BaseNetworkSocketGetErrorResponder)> {
        if let BaseNetworkSocketRequest::GetError { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_broadcast(self) -> Option<(bool, BaseNetworkSocketSetBroadcastResponder)> {
        if let BaseNetworkSocketRequest::SetBroadcast { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_broadcast(self) -> Option<(BaseNetworkSocketGetBroadcastResponder)> {
        if let BaseNetworkSocketRequest::GetBroadcast { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_send_buffer(self) -> Option<(u64, BaseNetworkSocketSetSendBufferResponder)> {
        if let BaseNetworkSocketRequest::SetSendBuffer { value_bytes, responder } = self {
            Some((value_bytes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_send_buffer(self) -> Option<(BaseNetworkSocketGetSendBufferResponder)> {
        if let BaseNetworkSocketRequest::GetSendBuffer { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_receive_buffer(
        self,
    ) -> Option<(u64, BaseNetworkSocketSetReceiveBufferResponder)> {
        if let BaseNetworkSocketRequest::SetReceiveBuffer { value_bytes, responder } = self {
            Some((value_bytes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_receive_buffer(self) -> Option<(BaseNetworkSocketGetReceiveBufferResponder)> {
        if let BaseNetworkSocketRequest::GetReceiveBuffer { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_keep_alive(self) -> Option<(bool, BaseNetworkSocketSetKeepAliveResponder)> {
        if let BaseNetworkSocketRequest::SetKeepAlive { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_keep_alive(self) -> Option<(BaseNetworkSocketGetKeepAliveResponder)> {
        if let BaseNetworkSocketRequest::GetKeepAlive { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_out_of_band_inline(
        self,
    ) -> Option<(bool, BaseNetworkSocketSetOutOfBandInlineResponder)> {
        if let BaseNetworkSocketRequest::SetOutOfBandInline { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_out_of_band_inline(
        self,
    ) -> Option<(BaseNetworkSocketGetOutOfBandInlineResponder)> {
        if let BaseNetworkSocketRequest::GetOutOfBandInline { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_no_check(self) -> Option<(bool, BaseNetworkSocketSetNoCheckResponder)> {
        if let BaseNetworkSocketRequest::SetNoCheck { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_no_check(self) -> Option<(BaseNetworkSocketGetNoCheckResponder)> {
        if let BaseNetworkSocketRequest::GetNoCheck { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_linger(self) -> Option<(bool, u32, BaseNetworkSocketSetLingerResponder)> {
        if let BaseNetworkSocketRequest::SetLinger { linger, length_secs, responder } = self {
            Some((linger, length_secs, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_linger(self) -> Option<(BaseNetworkSocketGetLingerResponder)> {
        if let BaseNetworkSocketRequest::GetLinger { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_reuse_port(self) -> Option<(bool, BaseNetworkSocketSetReusePortResponder)> {
        if let BaseNetworkSocketRequest::SetReusePort { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_reuse_port(self) -> Option<(BaseNetworkSocketGetReusePortResponder)> {
        if let BaseNetworkSocketRequest::GetReusePort { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_accept_conn(self) -> Option<(BaseNetworkSocketGetAcceptConnResponder)> {
        if let BaseNetworkSocketRequest::GetAcceptConn { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_bind_to_device(
        self,
    ) -> Option<(String, BaseNetworkSocketSetBindToDeviceResponder)> {
        if let BaseNetworkSocketRequest::SetBindToDevice { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_bind_to_device(self) -> Option<(BaseNetworkSocketGetBindToDeviceResponder)> {
        if let BaseNetworkSocketRequest::GetBindToDevice { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_bind_to_interface_index(
        self,
    ) -> Option<(u64, BaseNetworkSocketSetBindToInterfaceIndexResponder)> {
        if let BaseNetworkSocketRequest::SetBindToInterfaceIndex { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_bind_to_interface_index(
        self,
    ) -> Option<(BaseNetworkSocketGetBindToInterfaceIndexResponder)> {
        if let BaseNetworkSocketRequest::GetBindToInterfaceIndex { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_timestamp(
        self,
    ) -> Option<(TimestampOption, BaseNetworkSocketSetTimestampResponder)> {
        if let BaseNetworkSocketRequest::SetTimestamp { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_timestamp(self) -> Option<(BaseNetworkSocketGetTimestampResponder)> {
        if let BaseNetworkSocketRequest::GetTimestamp { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_mark(
        self,
    ) -> Option<(fidl_fuchsia_net::MarkDomain, OptionalUint32, BaseNetworkSocketSetMarkResponder)>
    {
        if let BaseNetworkSocketRequest::SetMark { domain, mark, responder } = self {
            Some((domain, mark, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_mark(
        self,
    ) -> Option<(fidl_fuchsia_net::MarkDomain, BaseNetworkSocketGetMarkResponder)> {
        if let BaseNetworkSocketRequest::GetMark { domain, responder } = self {
            Some((domain, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_cookie(self) -> Option<(BaseNetworkSocketGetCookieResponder)> {
        if let BaseNetworkSocketRequest::GetCookie { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind(
        self,
    ) -> Option<(fidl_fuchsia_net::SocketAddress, BaseNetworkSocketBindResponder)> {
        if let BaseNetworkSocketRequest::Bind { addr, responder } = self {
            Some((addr, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fidl_fuchsia_net::SocketAddress, BaseNetworkSocketConnectResponder)> {
        if let BaseNetworkSocketRequest::Connect { addr, responder } = self {
            Some((addr, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_disconnect(self) -> Option<(BaseNetworkSocketDisconnectResponder)> {
        if let BaseNetworkSocketRequest::Disconnect { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_sock_name(self) -> Option<(BaseNetworkSocketGetSockNameResponder)> {
        if let BaseNetworkSocketRequest::GetSockName { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_peer_name(self) -> Option<(BaseNetworkSocketGetPeerNameResponder)> {
        if let BaseNetworkSocketRequest::GetPeerName { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_shutdown(self) -> Option<(ShutdownMode, BaseNetworkSocketShutdownResponder)> {
        if let BaseNetworkSocketRequest::Shutdown { mode, responder } = self {
            Some((mode, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_type_of_service(
        self,
    ) -> Option<(u8, BaseNetworkSocketSetIpTypeOfServiceResponder)> {
        if let BaseNetworkSocketRequest::SetIpTypeOfService { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_type_of_service(
        self,
    ) -> Option<(BaseNetworkSocketGetIpTypeOfServiceResponder)> {
        if let BaseNetworkSocketRequest::GetIpTypeOfService { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_ttl(self) -> Option<(OptionalUint8, BaseNetworkSocketSetIpTtlResponder)> {
        if let BaseNetworkSocketRequest::SetIpTtl { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_ttl(self) -> Option<(BaseNetworkSocketGetIpTtlResponder)> {
        if let BaseNetworkSocketRequest::GetIpTtl { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_packet_info(
        self,
    ) -> Option<(bool, BaseNetworkSocketSetIpPacketInfoResponder)> {
        if let BaseNetworkSocketRequest::SetIpPacketInfo { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_packet_info(self) -> Option<(BaseNetworkSocketGetIpPacketInfoResponder)> {
        if let BaseNetworkSocketRequest::GetIpPacketInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_receive_type_of_service(
        self,
    ) -> Option<(bool, BaseNetworkSocketSetIpReceiveTypeOfServiceResponder)> {
        if let BaseNetworkSocketRequest::SetIpReceiveTypeOfService { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_receive_type_of_service(
        self,
    ) -> Option<(BaseNetworkSocketGetIpReceiveTypeOfServiceResponder)> {
        if let BaseNetworkSocketRequest::GetIpReceiveTypeOfService { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_receive_ttl(
        self,
    ) -> Option<(bool, BaseNetworkSocketSetIpReceiveTtlResponder)> {
        if let BaseNetworkSocketRequest::SetIpReceiveTtl { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_receive_ttl(self) -> Option<(BaseNetworkSocketGetIpReceiveTtlResponder)> {
        if let BaseNetworkSocketRequest::GetIpReceiveTtl { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_multicast_interface(
        self,
    ) -> Option<(
        u64,
        fidl_fuchsia_net::Ipv4Address,
        BaseNetworkSocketSetIpMulticastInterfaceResponder,
    )> {
        if let BaseNetworkSocketRequest::SetIpMulticastInterface { iface, address, responder } =
            self
        {
            Some((iface, address, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_multicast_interface(
        self,
    ) -> Option<(BaseNetworkSocketGetIpMulticastInterfaceResponder)> {
        if let BaseNetworkSocketRequest::GetIpMulticastInterface { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_multicast_ttl(
        self,
    ) -> Option<(OptionalUint8, BaseNetworkSocketSetIpMulticastTtlResponder)> {
        if let BaseNetworkSocketRequest::SetIpMulticastTtl { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_multicast_ttl(
        self,
    ) -> Option<(BaseNetworkSocketGetIpMulticastTtlResponder)> {
        if let BaseNetworkSocketRequest::GetIpMulticastTtl { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_multicast_loopback(
        self,
    ) -> Option<(bool, BaseNetworkSocketSetIpMulticastLoopbackResponder)> {
        if let BaseNetworkSocketRequest::SetIpMulticastLoopback { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_multicast_loopback(
        self,
    ) -> Option<(BaseNetworkSocketGetIpMulticastLoopbackResponder)> {
        if let BaseNetworkSocketRequest::GetIpMulticastLoopback { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_ip_membership(
        self,
    ) -> Option<(IpMulticastMembership, BaseNetworkSocketAddIpMembershipResponder)> {
        if let BaseNetworkSocketRequest::AddIpMembership { membership, responder } = self {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_drop_ip_membership(
        self,
    ) -> Option<(IpMulticastMembership, BaseNetworkSocketDropIpMembershipResponder)> {
        if let BaseNetworkSocketRequest::DropIpMembership { membership, responder } = self {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_transparent(
        self,
    ) -> Option<(bool, BaseNetworkSocketSetIpTransparentResponder)> {
        if let BaseNetworkSocketRequest::SetIpTransparent { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_transparent(self) -> Option<(BaseNetworkSocketGetIpTransparentResponder)> {
        if let BaseNetworkSocketRequest::GetIpTransparent { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_receive_original_destination_address(
        self,
    ) -> Option<(bool, BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder)> {
        if let BaseNetworkSocketRequest::SetIpReceiveOriginalDestinationAddress {
            value,
            responder,
        } = self
        {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_receive_original_destination_address(
        self,
    ) -> Option<(BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder)> {
        if let BaseNetworkSocketRequest::GetIpReceiveOriginalDestinationAddress { responder } = self
        {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_ipv6_membership(
        self,
    ) -> Option<(Ipv6MulticastMembership, BaseNetworkSocketAddIpv6MembershipResponder)> {
        if let BaseNetworkSocketRequest::AddIpv6Membership { membership, responder } = self {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_drop_ipv6_membership(
        self,
    ) -> Option<(Ipv6MulticastMembership, BaseNetworkSocketDropIpv6MembershipResponder)> {
        if let BaseNetworkSocketRequest::DropIpv6Membership { membership, responder } = self {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_multicast_interface(
        self,
    ) -> Option<(u64, BaseNetworkSocketSetIpv6MulticastInterfaceResponder)> {
        if let BaseNetworkSocketRequest::SetIpv6MulticastInterface { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_multicast_interface(
        self,
    ) -> Option<(BaseNetworkSocketGetIpv6MulticastInterfaceResponder)> {
        if let BaseNetworkSocketRequest::GetIpv6MulticastInterface { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_unicast_hops(
        self,
    ) -> Option<(OptionalUint8, BaseNetworkSocketSetIpv6UnicastHopsResponder)> {
        if let BaseNetworkSocketRequest::SetIpv6UnicastHops { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_unicast_hops(
        self,
    ) -> Option<(BaseNetworkSocketGetIpv6UnicastHopsResponder)> {
        if let BaseNetworkSocketRequest::GetIpv6UnicastHops { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_receive_hop_limit(
        self,
    ) -> Option<(bool, BaseNetworkSocketSetIpv6ReceiveHopLimitResponder)> {
        if let BaseNetworkSocketRequest::SetIpv6ReceiveHopLimit { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_receive_hop_limit(
        self,
    ) -> Option<(BaseNetworkSocketGetIpv6ReceiveHopLimitResponder)> {
        if let BaseNetworkSocketRequest::GetIpv6ReceiveHopLimit { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_multicast_hops(
        self,
    ) -> Option<(OptionalUint8, BaseNetworkSocketSetIpv6MulticastHopsResponder)> {
        if let BaseNetworkSocketRequest::SetIpv6MulticastHops { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_multicast_hops(
        self,
    ) -> Option<(BaseNetworkSocketGetIpv6MulticastHopsResponder)> {
        if let BaseNetworkSocketRequest::GetIpv6MulticastHops { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_multicast_loopback(
        self,
    ) -> Option<(bool, BaseNetworkSocketSetIpv6MulticastLoopbackResponder)> {
        if let BaseNetworkSocketRequest::SetIpv6MulticastLoopback { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_multicast_loopback(
        self,
    ) -> Option<(BaseNetworkSocketGetIpv6MulticastLoopbackResponder)> {
        if let BaseNetworkSocketRequest::GetIpv6MulticastLoopback { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_only(self) -> Option<(bool, BaseNetworkSocketSetIpv6OnlyResponder)> {
        if let BaseNetworkSocketRequest::SetIpv6Only { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_only(self) -> Option<(BaseNetworkSocketGetIpv6OnlyResponder)> {
        if let BaseNetworkSocketRequest::GetIpv6Only { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_receive_traffic_class(
        self,
    ) -> Option<(bool, BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder)> {
        if let BaseNetworkSocketRequest::SetIpv6ReceiveTrafficClass { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_receive_traffic_class(
        self,
    ) -> Option<(BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder)> {
        if let BaseNetworkSocketRequest::GetIpv6ReceiveTrafficClass { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_traffic_class(
        self,
    ) -> Option<(OptionalUint8, BaseNetworkSocketSetIpv6TrafficClassResponder)> {
        if let BaseNetworkSocketRequest::SetIpv6TrafficClass { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_traffic_class(
        self,
    ) -> Option<(BaseNetworkSocketGetIpv6TrafficClassResponder)> {
        if let BaseNetworkSocketRequest::GetIpv6TrafficClass { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_receive_packet_info(
        self,
    ) -> Option<(bool, BaseNetworkSocketSetIpv6ReceivePacketInfoResponder)> {
        if let BaseNetworkSocketRequest::SetIpv6ReceivePacketInfo { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_receive_packet_info(
        self,
    ) -> Option<(BaseNetworkSocketGetIpv6ReceivePacketInfoResponder)> {
        if let BaseNetworkSocketRequest::GetIpv6ReceivePacketInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_original_destination(
        self,
    ) -> Option<(BaseNetworkSocketGetOriginalDestinationResponder)> {
        if let BaseNetworkSocketRequest::GetOriginalDestination { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BaseNetworkSocketRequest::Clone { .. } => "clone",
            BaseNetworkSocketRequest::Close { .. } => "close",
            BaseNetworkSocketRequest::Query { .. } => "query",
            BaseNetworkSocketRequest::SetReuseAddress { .. } => "set_reuse_address",
            BaseNetworkSocketRequest::GetReuseAddress { .. } => "get_reuse_address",
            BaseNetworkSocketRequest::GetError { .. } => "get_error",
            BaseNetworkSocketRequest::SetBroadcast { .. } => "set_broadcast",
            BaseNetworkSocketRequest::GetBroadcast { .. } => "get_broadcast",
            BaseNetworkSocketRequest::SetSendBuffer { .. } => "set_send_buffer",
            BaseNetworkSocketRequest::GetSendBuffer { .. } => "get_send_buffer",
            BaseNetworkSocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
            BaseNetworkSocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
            BaseNetworkSocketRequest::SetKeepAlive { .. } => "set_keep_alive",
            BaseNetworkSocketRequest::GetKeepAlive { .. } => "get_keep_alive",
            BaseNetworkSocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
            BaseNetworkSocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
            BaseNetworkSocketRequest::SetNoCheck { .. } => "set_no_check",
            BaseNetworkSocketRequest::GetNoCheck { .. } => "get_no_check",
            BaseNetworkSocketRequest::SetLinger { .. } => "set_linger",
            BaseNetworkSocketRequest::GetLinger { .. } => "get_linger",
            BaseNetworkSocketRequest::SetReusePort { .. } => "set_reuse_port",
            BaseNetworkSocketRequest::GetReusePort { .. } => "get_reuse_port",
            BaseNetworkSocketRequest::GetAcceptConn { .. } => "get_accept_conn",
            BaseNetworkSocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
            BaseNetworkSocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
            BaseNetworkSocketRequest::SetBindToInterfaceIndex { .. } => {
                "set_bind_to_interface_index"
            }
            BaseNetworkSocketRequest::GetBindToInterfaceIndex { .. } => {
                "get_bind_to_interface_index"
            }
            BaseNetworkSocketRequest::SetTimestamp { .. } => "set_timestamp",
            BaseNetworkSocketRequest::GetTimestamp { .. } => "get_timestamp",
            BaseNetworkSocketRequest::SetMark { .. } => "set_mark",
            BaseNetworkSocketRequest::GetMark { .. } => "get_mark",
            BaseNetworkSocketRequest::GetCookie { .. } => "get_cookie",
            BaseNetworkSocketRequest::Bind { .. } => "bind",
            BaseNetworkSocketRequest::Connect { .. } => "connect",
            BaseNetworkSocketRequest::Disconnect { .. } => "disconnect",
            BaseNetworkSocketRequest::GetSockName { .. } => "get_sock_name",
            BaseNetworkSocketRequest::GetPeerName { .. } => "get_peer_name",
            BaseNetworkSocketRequest::Shutdown { .. } => "shutdown",
            BaseNetworkSocketRequest::SetIpTypeOfService { .. } => "set_ip_type_of_service",
            BaseNetworkSocketRequest::GetIpTypeOfService { .. } => "get_ip_type_of_service",
            BaseNetworkSocketRequest::SetIpTtl { .. } => "set_ip_ttl",
            BaseNetworkSocketRequest::GetIpTtl { .. } => "get_ip_ttl",
            BaseNetworkSocketRequest::SetIpPacketInfo { .. } => "set_ip_packet_info",
            BaseNetworkSocketRequest::GetIpPacketInfo { .. } => "get_ip_packet_info",
            BaseNetworkSocketRequest::SetIpReceiveTypeOfService { .. } => {
                "set_ip_receive_type_of_service"
            }
            BaseNetworkSocketRequest::GetIpReceiveTypeOfService { .. } => {
                "get_ip_receive_type_of_service"
            }
            BaseNetworkSocketRequest::SetIpReceiveTtl { .. } => "set_ip_receive_ttl",
            BaseNetworkSocketRequest::GetIpReceiveTtl { .. } => "get_ip_receive_ttl",
            BaseNetworkSocketRequest::SetIpMulticastInterface { .. } => {
                "set_ip_multicast_interface"
            }
            BaseNetworkSocketRequest::GetIpMulticastInterface { .. } => {
                "get_ip_multicast_interface"
            }
            BaseNetworkSocketRequest::SetIpMulticastTtl { .. } => "set_ip_multicast_ttl",
            BaseNetworkSocketRequest::GetIpMulticastTtl { .. } => "get_ip_multicast_ttl",
            BaseNetworkSocketRequest::SetIpMulticastLoopback { .. } => "set_ip_multicast_loopback",
            BaseNetworkSocketRequest::GetIpMulticastLoopback { .. } => "get_ip_multicast_loopback",
            BaseNetworkSocketRequest::AddIpMembership { .. } => "add_ip_membership",
            BaseNetworkSocketRequest::DropIpMembership { .. } => "drop_ip_membership",
            BaseNetworkSocketRequest::SetIpTransparent { .. } => "set_ip_transparent",
            BaseNetworkSocketRequest::GetIpTransparent { .. } => "get_ip_transparent",
            BaseNetworkSocketRequest::SetIpReceiveOriginalDestinationAddress { .. } => {
                "set_ip_receive_original_destination_address"
            }
            BaseNetworkSocketRequest::GetIpReceiveOriginalDestinationAddress { .. } => {
                "get_ip_receive_original_destination_address"
            }
            BaseNetworkSocketRequest::AddIpv6Membership { .. } => "add_ipv6_membership",
            BaseNetworkSocketRequest::DropIpv6Membership { .. } => "drop_ipv6_membership",
            BaseNetworkSocketRequest::SetIpv6MulticastInterface { .. } => {
                "set_ipv6_multicast_interface"
            }
            BaseNetworkSocketRequest::GetIpv6MulticastInterface { .. } => {
                "get_ipv6_multicast_interface"
            }
            BaseNetworkSocketRequest::SetIpv6UnicastHops { .. } => "set_ipv6_unicast_hops",
            BaseNetworkSocketRequest::GetIpv6UnicastHops { .. } => "get_ipv6_unicast_hops",
            BaseNetworkSocketRequest::SetIpv6ReceiveHopLimit { .. } => "set_ipv6_receive_hop_limit",
            BaseNetworkSocketRequest::GetIpv6ReceiveHopLimit { .. } => "get_ipv6_receive_hop_limit",
            BaseNetworkSocketRequest::SetIpv6MulticastHops { .. } => "set_ipv6_multicast_hops",
            BaseNetworkSocketRequest::GetIpv6MulticastHops { .. } => "get_ipv6_multicast_hops",
            BaseNetworkSocketRequest::SetIpv6MulticastLoopback { .. } => {
                "set_ipv6_multicast_loopback"
            }
            BaseNetworkSocketRequest::GetIpv6MulticastLoopback { .. } => {
                "get_ipv6_multicast_loopback"
            }
            BaseNetworkSocketRequest::SetIpv6Only { .. } => "set_ipv6_only",
            BaseNetworkSocketRequest::GetIpv6Only { .. } => "get_ipv6_only",
            BaseNetworkSocketRequest::SetIpv6ReceiveTrafficClass { .. } => {
                "set_ipv6_receive_traffic_class"
            }
            BaseNetworkSocketRequest::GetIpv6ReceiveTrafficClass { .. } => {
                "get_ipv6_receive_traffic_class"
            }
            BaseNetworkSocketRequest::SetIpv6TrafficClass { .. } => "set_ipv6_traffic_class",
            BaseNetworkSocketRequest::GetIpv6TrafficClass { .. } => "get_ipv6_traffic_class",
            BaseNetworkSocketRequest::SetIpv6ReceivePacketInfo { .. } => {
                "set_ipv6_receive_packet_info"
            }
            BaseNetworkSocketRequest::GetIpv6ReceivePacketInfo { .. } => {
                "get_ipv6_receive_packet_info"
            }
            BaseNetworkSocketRequest::GetOriginalDestination { .. } => "get_original_destination",
        }
    }
}

#[derive(Debug, Clone)]
pub struct BaseNetworkSocketControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for BaseNetworkSocketControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl BaseNetworkSocketControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketCloseResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketCloseResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketCloseResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketCloseResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
                result,
                self.tx_id,
                0x5ac5d459ad7f657e,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketQueryResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketQueryResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketQueryResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketQueryResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(protocol);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(protocol);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
            (protocol,),
            self.tx_id,
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetReuseAddressResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetReuseAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetReuseAddressResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetReuseAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x1fd74ee8b9a4a876,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetReuseAddressResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetReuseAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetReuseAddressResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetReuseAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetReuseAddressResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x67b7206b8d1bc0a5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetErrorResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetErrorResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetErrorResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetErrorResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x5aad39b33e5f6ebb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetBroadcastResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetBroadcastResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetBroadcastResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetBroadcastResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6023e081ce3cd947,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetBroadcastResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetBroadcastResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetBroadcastResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetBroadcastResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetBroadcastResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x68796fc556f9780d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetSendBufferResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetSendBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetSendBufferResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetSendBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x756eac32d73a7a70,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetSendBufferResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetSendBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetSendBufferResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetSendBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetSendBufferResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value_bytes| (value_bytes,)),
            self.tx_id,
            0x78a52fd9c7b2410b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetReceiveBufferResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetReceiveBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetReceiveBufferResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetReceiveBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6b0cf2f1919c7001,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetReceiveBufferResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetReceiveBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetReceiveBufferResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetReceiveBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetReceiveBufferResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value_bytes| (value_bytes,)),
            self.tx_id,
            0x14c1a4b64f709e5c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetKeepAliveResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetKeepAliveResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetKeepAliveResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetKeepAliveResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x572df8f0b920d2c7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetKeepAliveResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetKeepAliveResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetKeepAliveResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetKeepAliveResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetKeepAliveResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2dd29d3215f2c9d2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetOutOfBandInlineResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetOutOfBandInlineResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetOutOfBandInlineResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetOutOfBandInlineResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x3ecb49968bee439,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetOutOfBandInlineResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetOutOfBandInlineResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetOutOfBandInlineResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetOutOfBandInlineResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetOutOfBandInlineResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x348c1ab3aeca1745,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetNoCheckResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetNoCheckResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetNoCheckResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetNoCheckResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6bbf00c53a4c78c2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetNoCheckResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetNoCheckResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetNoCheckResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetNoCheckResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetNoCheckResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2cd4249286417694,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetLingerResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetLingerResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetLingerResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetLingerResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x45386351246e998e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetLingerResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetLingerResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetLingerResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetLingerResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetLingerResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x48eb20fc5ccb0e45,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetReusePortResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetReusePortResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetReusePortResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetReusePortResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x24dd3e5cb36d9ccb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetReusePortResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetReusePortResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetReusePortResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetReusePortResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetReusePortResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x7a112c1ab54ff828,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetAcceptConnResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetAcceptConnResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetAcceptConnResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetAcceptConnResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetAcceptConnResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x67ce6db6c2ec8966,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetBindToDeviceResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetBindToDeviceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetBindToDeviceResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetBindToDeviceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x2118b483f28aafc4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetBindToDeviceResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetBindToDeviceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetBindToDeviceResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetBindToDeviceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetBindToDeviceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x1ab1fbf0ef7906c8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetBindToInterfaceIndexResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetBindToInterfaceIndexResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetBindToInterfaceIndexResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetBindToInterfaceIndexResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6e387a0def00821,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetBindToInterfaceIndexResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetBindToInterfaceIndexResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetBindToInterfaceIndexResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetBindToInterfaceIndexResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetBindToInterfaceIndexResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x59c31dd3e3078295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetTimestampResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetTimestampResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetTimestampResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetTimestampResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x285d6516c263d839,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetTimestampResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetTimestampResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetTimestampResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetTimestampResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetTimestampResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x49f2fffbbcc2bd27,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetMarkResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetMarkResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetMarkResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetMarkResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6ead6de09f653236,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetMarkResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetMarkResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetMarkResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetMarkResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetMarkResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|mark| (mark,)),
            self.tx_id,
            0x57a2752c61d93d47,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetCookieResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetCookieResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetCookieResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetCookieResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetCookieResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2c2f47fd8f924e52,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketBindResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketBindResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketBindResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketBindResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x4bc6400ae92125d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketConnectResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketConnectResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketConnectResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketConnectResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x5f05f19bfdd38871,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketDisconnectResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketDisconnectResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketDisconnectResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketDisconnectResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x74e63b91f7b29b2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetSockNameResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetSockNameResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetSockNameResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetSockNameResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetSockNameResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|addr| (addr,)),
            self.tx_id,
            0x475f23f84a1a4f85,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetPeerNameResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetPeerNameResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetPeerNameResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetPeerNameResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetPeerNameResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|addr| (addr,)),
            self.tx_id,
            0x1ffecf4bd5b6432e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketShutdownResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketShutdownResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketShutdownResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketShutdownResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x247f38b6db68c336,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetIpTypeOfServiceResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x995c600475b6d46,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetIpTypeOfServiceResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpTypeOfServiceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x3814a04259f75fcb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpTtlResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetIpTtlResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x29e2424b433ae1ef,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpTtlResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetIpTtlResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpTtlResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x47e47fa1f24da471,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpPacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpPacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetIpPacketInfoResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpPacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x392d16bee20c0e16,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpPacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpPacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetIpPacketInfoResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpPacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpPacketInfoResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x54b505f242280740,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpReceiveTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpReceiveTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetIpReceiveTypeOfServiceResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpReceiveTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6c4f6714995f84ef,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpReceiveTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpReceiveTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetIpReceiveTypeOfServiceResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpReceiveTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4158ba7dc2795960,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpReceiveTtlResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpReceiveTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetIpReceiveTtlResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpReceiveTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x46f15be0ce0ab82b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpReceiveTtlResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpReceiveTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetIpReceiveTtlResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpReceiveTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpReceiveTtlResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x678ddd5a5dfa2eb5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpMulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpMulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetIpMulticastInterfaceResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpMulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x752fbfa9b12befe,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpMulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpMulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetIpMulticastInterfaceResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpMulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpMulticastInterfaceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x320bd14c4df046c4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpMulticastTtlResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpMulticastTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetIpMulticastTtlResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpMulticastTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x63134d53772916a1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpMulticastTtlResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpMulticastTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetIpMulticastTtlResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpMulticastTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpMulticastTtlResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4665cd378f39e1a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpMulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpMulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetIpMulticastLoopbackResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpMulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x20c55c11f00943ea,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpMulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpMulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetIpMulticastLoopbackResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpMulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpMulticastLoopbackResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x3b6b26ff558298f2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketAddIpMembershipResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketAddIpMembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketAddIpMembershipResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketAddIpMembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x76bc7df115a3b4d0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketDropIpMembershipResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketDropIpMembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketDropIpMembershipResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketDropIpMembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x2888f3099188d03,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpTransparentResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpTransparentResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetIpTransparentResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpTransparentResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x1ae532b0c066e3a0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpTransparentResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpTransparentResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetIpTransparentResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpTransparentResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpTransparentResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x51d43695962ebfb5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder
    for BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder
{
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x4722b4ce52f7840,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder
    for BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder
{
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2a0e7dc5d6bfdfe9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketAddIpv6MembershipResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketAddIpv6MembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketAddIpv6MembershipResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketAddIpv6MembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x7c94727acb4ea4b3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketDropIpv6MembershipResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketDropIpv6MembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketDropIpv6MembershipResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketDropIpv6MembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x42104c70ccaba304,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpv6MulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpv6MulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6MulticastInterfaceResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpv6MulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x135f76db3774ab3b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpv6MulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpv6MulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6MulticastInterfaceResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpv6MulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x1f26fcdd348f1882,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpv6UnicastHopsResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpv6UnicastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6UnicastHopsResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpv6UnicastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x157d51e98f462859,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpv6UnicastHopsResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpv6UnicastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6UnicastHopsResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpv6UnicastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6UnicastHopsResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x21f4641cad8bd8d2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpv6ReceiveHopLimitResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpv6ReceiveHopLimitResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6ReceiveHopLimitResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpv6ReceiveHopLimitResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x5c24808ed2e84a1e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpv6ReceiveHopLimitResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpv6ReceiveHopLimitResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6ReceiveHopLimitResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpv6ReceiveHopLimitResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x341e06689885b4c0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpv6MulticastHopsResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpv6MulticastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6MulticastHopsResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpv6MulticastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x25b9cd4d181f82c1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpv6MulticastHopsResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpv6MulticastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6MulticastHopsResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpv6MulticastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6MulticastHopsResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x52916948a365012a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpv6MulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpv6MulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6MulticastLoopbackResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpv6MulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x55701c409ff41b40,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpv6MulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpv6MulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6MulticastLoopbackResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpv6MulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4415b701fde319c3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpv6OnlyResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpv6OnlyResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6OnlyResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpv6OnlyResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x4873f1364758cbba,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpv6OnlyResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpv6OnlyResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6OnlyResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpv6OnlyResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6OnlyResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4aa3340a1a26b89c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x58f07c8788d099a0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2e334df1da553ffa,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpv6TrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpv6TrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6TrafficClassResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpv6TrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6af077800c5a0b4f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpv6TrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpv6TrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6TrafficClassResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpv6TrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6TrafficClassResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x6baf6eed8fc2f04,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketSetIpv6ReceivePacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketSetIpv6ReceivePacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6ReceivePacketInfoResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketSetIpv6ReceivePacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x19259775b1a92768,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetIpv6ReceivePacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetIpv6ReceivePacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6ReceivePacketInfoResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetIpv6ReceivePacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x7acd4a2775baec75,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseNetworkSocketGetOriginalDestinationResponder {
    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseNetworkSocketGetOriginalDestinationResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseNetworkSocketGetOriginalDestinationResponder {
    type ControlHandle = BaseNetworkSocketControlHandle;

    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseNetworkSocketGetOriginalDestinationResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetOriginalDestinationResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x38bf28f0dafdbac0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct BaseSocketMarker;

impl fidl::endpoints::ProtocolMarker for BaseSocketMarker {
    type Proxy = BaseSocketProxy;
    type RequestStream = BaseSocketRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = BaseSocketSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) BaseSocket";
}
pub type BaseSocketSetReuseAddressResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseSocketGetReuseAddressResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type BaseSocketGetErrorResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseSocketSetBroadcastResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseSocketGetBroadcastResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type BaseSocketSetSendBufferResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseSocketGetSendBufferResult = Result<u64, fidl_fuchsia_posix::Errno>;
pub type BaseSocketSetReceiveBufferResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseSocketGetReceiveBufferResult = Result<u64, fidl_fuchsia_posix::Errno>;
pub type BaseSocketSetKeepAliveResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseSocketGetKeepAliveResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type BaseSocketSetOutOfBandInlineResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseSocketGetOutOfBandInlineResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type BaseSocketSetNoCheckResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseSocketGetNoCheckResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type BaseSocketSetLingerResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseSocketGetLingerResult = Result<(bool, u32), fidl_fuchsia_posix::Errno>;
pub type BaseSocketSetReusePortResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseSocketGetReusePortResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type BaseSocketGetAcceptConnResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type BaseSocketSetBindToDeviceResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseSocketGetBindToDeviceResult = Result<String, fidl_fuchsia_posix::Errno>;
pub type BaseSocketSetBindToInterfaceIndexResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseSocketGetBindToInterfaceIndexResult = Result<u64, fidl_fuchsia_posix::Errno>;
pub type BaseSocketSetTimestampResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseSocketGetTimestampResult = Result<TimestampOption, fidl_fuchsia_posix::Errno>;
pub type BaseSocketSetMarkResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type BaseSocketGetMarkResult = Result<OptionalUint32, fidl_fuchsia_posix::Errno>;
pub type BaseSocketGetCookieResult = Result<u64, fidl_fuchsia_posix::Errno>;

pub trait BaseSocketProxyInterface: Send + Sync {
    fn r#clone(
        &self,
        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error>;
    type CloseResponseFut: std::future::Future<
            Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
        > + Send;
    fn r#close(&self) -> Self::CloseResponseFut;
    type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
    fn r#query(&self) -> Self::QueryResponseFut;
    type SetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketSetReuseAddressResult, fidl::Error>>
        + Send;
    fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
    type GetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketGetReuseAddressResult, fidl::Error>>
        + Send;
    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
    type GetErrorResponseFut: std::future::Future<Output = Result<BaseSocketGetErrorResult, fidl::Error>>
        + Send;
    fn r#get_error(&self) -> Self::GetErrorResponseFut;
    type SetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketSetBroadcastResult, fidl::Error>>
        + Send;
    fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
    type GetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketGetBroadcastResult, fidl::Error>>
        + Send;
    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
    type SetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetSendBufferResult, fidl::Error>>
        + Send;
    fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
    type GetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetSendBufferResult, fidl::Error>>
        + Send;
    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
    type SetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetReceiveBufferResult, fidl::Error>>
        + Send;
    fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
    type GetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetReceiveBufferResult, fidl::Error>>
        + Send;
    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
    type SetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketSetKeepAliveResult, fidl::Error>>
        + Send;
    fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
    type GetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketGetKeepAliveResult, fidl::Error>>
        + Send;
    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
    type SetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketSetOutOfBandInlineResult, fidl::Error>>
        + Send;
    fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
    type GetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketGetOutOfBandInlineResult, fidl::Error>>
        + Send;
    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
    type SetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketSetNoCheckResult, fidl::Error>>
        + Send;
    fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
    type GetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketGetNoCheckResult, fidl::Error>>
        + Send;
    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
    type SetLingerResponseFut: std::future::Future<Output = Result<BaseSocketSetLingerResult, fidl::Error>>
        + Send;
    fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
    type GetLingerResponseFut: std::future::Future<Output = Result<BaseSocketGetLingerResult, fidl::Error>>
        + Send;
    fn r#get_linger(&self) -> Self::GetLingerResponseFut;
    type SetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketSetReusePortResult, fidl::Error>>
        + Send;
    fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
    type GetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketGetReusePortResult, fidl::Error>>
        + Send;
    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
    type GetAcceptConnResponseFut: std::future::Future<Output = Result<BaseSocketGetAcceptConnResult, fidl::Error>>
        + Send;
    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
    type SetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToDeviceResult, fidl::Error>>
        + Send;
    fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
    type GetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToDeviceResult, fidl::Error>>
        + Send;
    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
    type SetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error>>
        + Send;
    fn r#set_bind_to_interface_index(&self, value: u64)
    -> Self::SetBindToInterfaceIndexResponseFut;
    type GetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error>>
        + Send;
    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
    type SetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketSetTimestampResult, fidl::Error>>
        + Send;
    fn r#set_timestamp(&self, value: TimestampOption) -> Self::SetTimestampResponseFut;
    type GetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketGetTimestampResult, fidl::Error>>
        + Send;
    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
    type SetMarkResponseFut: std::future::Future<Output = Result<BaseSocketSetMarkResult, fidl::Error>>
        + Send;
    fn r#set_mark(
        &self,
        domain: fidl_fuchsia_net::MarkDomain,
        mark: &OptionalUint32,
    ) -> Self::SetMarkResponseFut;
    type GetMarkResponseFut: std::future::Future<Output = Result<BaseSocketGetMarkResult, fidl::Error>>
        + Send;
    fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
    type GetCookieResponseFut: std::future::Future<Output = Result<BaseSocketGetCookieResult, fidl::Error>>
        + Send;
    fn r#get_cookie(&self) -> Self::GetCookieResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct BaseSocketSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for BaseSocketSynchronousProxy {
    type Proxy = BaseSocketProxy;
    type Protocol = BaseSocketMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl BaseSocketSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <BaseSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketEvent, fidl::Error> {
        BaseSocketEvent::decode(self.client.wait_for_event(deadline)?)
    }

    pub fn r#clone(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_unknown::QueryableQueryResponse,
        >(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.protocol)
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#set_reuse_address(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetReuseAddressRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x1fd74ee8b9a4a876,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#get_reuse_address(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetReuseAddressResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Get `SOL_SOCKET` -> `SO_ERROR`.
    /// Returns the last error if there is an error set on the socket.
    pub fn r#get_error(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x5aad39b33e5f6ebb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#set_broadcast(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetBroadcastRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x6023e081ce3cd947,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#get_broadcast(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetBroadcastResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x68796fc556f9780d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#set_send_buffer(
        &self,
        mut value_bytes: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetSendBufferRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value_bytes,),
                0x756eac32d73a7a70,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#get_send_buffer(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetSendBufferResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value_bytes))
    }

    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#set_receive_buffer(
        &self,
        mut value_bytes: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseSocketSetReceiveBufferRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value_bytes,),
                    0x6b0cf2f1919c7001,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#get_receive_buffer(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetReceiveBufferResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value_bytes))
    }

    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#set_keep_alive(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetKeepAliveRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x572df8f0b920d2c7,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#get_keep_alive(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetKeepAliveResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x2dd29d3215f2c9d2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#set_out_of_band_inline(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseSocketSetOutOfBandInlineRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x3ecb49968bee439,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#get_out_of_band_inline(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetOutOfBandInlineResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#set_no_check(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetNoCheckRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x6bbf00c53a4c78c2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#get_no_check(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetNoCheckResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x2cd4249286417694,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#set_linger(
        &self,
        mut linger: bool,
        mut length_secs: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetLingerRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (linger, length_secs),
                0x45386351246e998e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#get_linger(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetLingerResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x48eb20fc5ccb0e45,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| (x.linger, x.length_secs)))
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#set_reuse_port(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetReusePortRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x24dd3e5cb36d9ccb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#get_reuse_port(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetReusePortResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x7a112c1ab54ff828,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
    pub fn r#get_accept_conn(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetAcceptConnResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#set_bind_to_device(
        &self,
        mut value: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetBindToDeviceRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x2118b483f28aafc4,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#get_bind_to_device(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetBindToDeviceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    /// If `value` is 0, this clears the bound interface.
    pub fn r#set_bind_to_interface_index(
        &self,
        mut value: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x6e387a0def00821,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    pub fn r#get_bind_to_interface_index(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetBindToInterfaceIndexResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#set_timestamp(
        &self,
        mut value: TimestampOption,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetTimestampRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x285d6516c263d839,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#get_timestamp(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetTimestampResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x49f2fffbbcc2bd27,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be set independently in each domain.
    pub fn r#set_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        mut mark: &OptionalUint32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetMarkRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (domain, mark),
                0x6ead6de09f653236,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be retrieved independently in each domain.
    pub fn r#get_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketGetMarkRequest, fidl::encoding::ResultType<
                BaseSocketGetMarkResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (domain,),
                0x57a2752c61d93d47,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.mark))
    }

    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
    pub fn r#get_cookie(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetCookieResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetCookieResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x2c2f47fd8f924e52,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }
}

#[cfg(target_os = "fuchsia")]
impl From<BaseSocketSynchronousProxy> for zx::Handle {
    fn from(value: BaseSocketSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for BaseSocketSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for BaseSocketSynchronousProxy {
    type Protocol = BaseSocketMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<BaseSocketMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct BaseSocketProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for BaseSocketProxy {
    type Protocol = BaseSocketMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl BaseSocketProxy {
    /// Create a new Proxy for fuchsia.posix.socket/BaseSocket.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <BaseSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> BaseSocketEventStream {
        BaseSocketEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#clone(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        BaseSocketProxyInterface::r#clone(self, request)
    }

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#close(self)
    }

    pub fn r#query(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        BaseSocketProxyInterface::r#query(self)
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#set_reuse_address(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#set_reuse_address(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#get_reuse_address(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#get_reuse_address(self)
    }

    /// Get `SOL_SOCKET` -> `SO_ERROR`.
    /// Returns the last error if there is an error set on the socket.
    pub fn r#get_error(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetErrorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#get_error(self)
    }

    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#set_broadcast(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#set_broadcast(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#get_broadcast(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#get_broadcast(self)
    }

    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#set_send_buffer(
        &self,
        mut value_bytes: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#set_send_buffer(self, value_bytes)
    }

    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#get_send_buffer(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#get_send_buffer(self)
    }

    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#set_receive_buffer(
        &self,
        mut value_bytes: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#set_receive_buffer(self, value_bytes)
    }

    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#get_receive_buffer(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#get_receive_buffer(self)
    }

    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#set_keep_alive(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#set_keep_alive(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#get_keep_alive(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#get_keep_alive(self)
    }

    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#set_out_of_band_inline(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#set_out_of_band_inline(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#get_out_of_band_inline(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#get_out_of_band_inline(self)
    }

    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#set_no_check(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#set_no_check(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#get_no_check(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#get_no_check(self)
    }

    /// Set `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#set_linger(
        &self,
        mut linger: bool,
        mut length_secs: u32,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#set_linger(self, linger, length_secs)
    }

    /// Get `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#get_linger(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#get_linger(self)
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#set_reuse_port(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#set_reuse_port(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#get_reuse_port(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#get_reuse_port(self)
    }

    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
    pub fn r#get_accept_conn(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetAcceptConnResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#get_accept_conn(self)
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#set_bind_to_device(
        &self,
        mut value: &str,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#set_bind_to_device(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#get_bind_to_device(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#get_bind_to_device(self)
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    /// If `value` is 0, this clears the bound interface.
    pub fn r#set_bind_to_interface_index(
        &self,
        mut value: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#set_bind_to_interface_index(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    pub fn r#get_bind_to_interface_index(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#get_bind_to_interface_index(self)
    }

    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#set_timestamp(
        &self,
        mut value: TimestampOption,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#set_timestamp(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#get_timestamp(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#get_timestamp(self)
    }

    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be set independently in each domain.
    pub fn r#set_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        mut mark: &OptionalUint32,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#set_mark(self, domain, mark)
    }

    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be retrieved independently in each domain.
    pub fn r#get_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#get_mark(self, domain)
    }

    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
    pub fn r#get_cookie(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetCookieResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        BaseSocketProxyInterface::r#get_cookie(self)
    }
}

impl BaseSocketProxyInterface for BaseSocketProxy {
    fn r#clone(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type CloseResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#close(&self) -> Self::CloseResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5ac5d459ad7f657e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_unknown::CloseableCloseResult,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryResponseFut =
        fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#query(&self) -> Self::QueryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<u8>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl_fuchsia_unknown::QueryableQueryResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2658edee9decfc06,
            >(_buf?)?;
            Ok(_response.protocol)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1fd74ee8b9a4a876,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetReuseAddressRequest,
            BaseSocketSetReuseAddressResult,
        >(
            (value,),
            0x1fd74ee8b9a4a876,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetReuseAddressResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x67b7206b8d1bc0a5,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReuseAddressResult>(
                (),
                0x67b7206b8d1bc0a5,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetErrorResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetErrorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_error(&self) -> Self::GetErrorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5aad39b33e5f6ebb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetErrorResult>(
            (),
            0x5aad39b33e5f6ebb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6023e081ce3cd947,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetBroadcastRequest, BaseSocketSetBroadcastResult>(
                (value,),
                0x6023e081ce3cd947,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetBroadcastResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x68796fc556f9780d,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBroadcastResult>(
                (),
                0x68796fc556f9780d,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x756eac32d73a7a70,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetSendBufferRequest, BaseSocketSetSendBufferResult>(
                (value_bytes,),
                0x756eac32d73a7a70,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetSendBufferResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x78a52fd9c7b2410b,
            >(_buf?)?;
            Ok(_response.map(|x| x.value_bytes))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetSendBufferResult>(
                (),
                0x78a52fd9c7b2410b,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6b0cf2f1919c7001,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetReceiveBufferRequest,
            BaseSocketSetReceiveBufferResult,
        >(
            (value_bytes,),
            0x6b0cf2f1919c7001,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetReceiveBufferResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x14c1a4b64f709e5c,
            >(_buf?)?;
            Ok(_response.map(|x| x.value_bytes))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseSocketGetReceiveBufferResult,
        >(
            (),
            0x14c1a4b64f709e5c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x572df8f0b920d2c7,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetKeepAliveRequest, BaseSocketSetKeepAliveResult>(
                (value,),
                0x572df8f0b920d2c7,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetKeepAliveResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2dd29d3215f2c9d2,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetKeepAliveResult>(
                (),
                0x2dd29d3215f2c9d2,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3ecb49968bee439,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetOutOfBandInlineRequest,
            BaseSocketSetOutOfBandInlineResult,
        >(
            (value,),
            0x3ecb49968bee439,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetOutOfBandInlineResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x348c1ab3aeca1745,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseSocketGetOutOfBandInlineResult,
        >(
            (),
            0x348c1ab3aeca1745,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6bbf00c53a4c78c2,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetNoCheckRequest, BaseSocketSetNoCheckResult>(
                (value,),
                0x6bbf00c53a4c78c2,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetNoCheckResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2cd4249286417694,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetNoCheckResult>(
                (),
                0x2cd4249286417694,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetLingerResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x45386351246e998e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<BaseSocketSetLingerRequest, BaseSocketSetLingerResult>(
            (linger, length_secs),
            0x45386351246e998e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetLingerResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_linger(&self) -> Self::GetLingerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetLingerResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x48eb20fc5ccb0e45,
            >(_buf?)?;
            Ok(_response.map(|x| (x.linger, x.length_secs)))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetLingerResult>(
                (),
                0x48eb20fc5ccb0e45,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetReusePortResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x24dd3e5cb36d9ccb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetReusePortRequest, BaseSocketSetReusePortResult>(
                (value,),
                0x24dd3e5cb36d9ccb,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetReusePortResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetReusePortResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7a112c1ab54ff828,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReusePortResult>(
                (),
                0x7a112c1ab54ff828,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetAcceptConnResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetAcceptConnResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x67ce6db6c2ec8966,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetAcceptConnResult>(
                (),
                0x67ce6db6c2ec8966,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2118b483f28aafc4,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetBindToDeviceRequest,
            BaseSocketSetBindToDeviceResult,
        >(
            (value,),
            0x2118b483f28aafc4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetBindToDeviceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ab1fbf0ef7906c8,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBindToDeviceResult>(
                (),
                0x1ab1fbf0ef7906c8,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_bind_to_interface_index(
        &self,
        mut value: u64,
    ) -> Self::SetBindToInterfaceIndexResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6e387a0def00821,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetBindToInterfaceIndexRequest,
            BaseSocketSetBindToInterfaceIndexResult,
        >(
            (value,),
            0x6e387a0def00821,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetBindToInterfaceIndexResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x59c31dd3e3078295,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseSocketGetBindToInterfaceIndexResult,
        >(
            (),
            0x59c31dd3e3078295,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetTimestampResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_timestamp(&self, mut value: TimestampOption) -> Self::SetTimestampResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x285d6516c263d839,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetTimestampRequest, BaseSocketSetTimestampResult>(
                (value,),
                0x285d6516c263d839,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetTimestampResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetTimestampResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x49f2fffbbcc2bd27,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetTimestampResult>(
                (),
                0x49f2fffbbcc2bd27,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetMarkResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        mut mark: &OptionalUint32,
    ) -> Self::SetMarkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6ead6de09f653236,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<BaseSocketSetMarkRequest, BaseSocketSetMarkResult>(
            (domain, mark),
            0x6ead6de09f653236,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetMarkResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x57a2752c61d93d47,
            >(_buf?)?;
            Ok(_response.map(|x| x.mark))
        }
        self.client.send_query_and_decode::<BaseSocketGetMarkRequest, BaseSocketGetMarkResult>(
            (domain,),
            0x57a2752c61d93d47,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetCookieResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetCookieResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_cookie(&self) -> Self::GetCookieResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetCookieResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetCookieResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2c2f47fd8f924e52,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetCookieResult>(
                (),
                0x2c2f47fd8f924e52,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

pub struct BaseSocketEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for BaseSocketEventStream {}

impl futures::stream::FusedStream for BaseSocketEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for BaseSocketEventStream {
    type Item = Result<BaseSocketEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(BaseSocketEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum BaseSocketEvent {}

impl BaseSocketEvent {
    /// Decodes a message buffer as a [`BaseSocketEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<BaseSocketEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <BaseSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.posix.socket/BaseSocket.
pub struct BaseSocketRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for BaseSocketRequestStream {}

impl futures::stream::FusedStream for BaseSocketRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for BaseSocketRequestStream {
    type Protocol = BaseSocketMarker;
    type ControlHandle = BaseSocketControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        BaseSocketControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for BaseSocketRequestStream {
    type Item = Result<BaseSocketRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled BaseSocketRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x20d8a7aba2168a79 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl_fuchsia_unknown::CloneableCloneRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::Clone { request: req.request, control_handle })
                    }
                    0x5ac5d459ad7f657e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::Close {
                            responder: BaseSocketCloseResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2658edee9decfc06 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::Query {
                            responder: BaseSocketQueryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1fd74ee8b9a4a876 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetReuseAddressRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::SetReuseAddress {
                            value: req.value,

                            responder: BaseSocketSetReuseAddressResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x67b7206b8d1bc0a5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::GetReuseAddress {
                            responder: BaseSocketGetReuseAddressResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5aad39b33e5f6ebb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::GetError {
                            responder: BaseSocketGetErrorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6023e081ce3cd947 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetBroadcastRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::SetBroadcast {
                            value: req.value,

                            responder: BaseSocketSetBroadcastResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x68796fc556f9780d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::GetBroadcast {
                            responder: BaseSocketGetBroadcastResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x756eac32d73a7a70 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetSendBufferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::SetSendBuffer {
                            value_bytes: req.value_bytes,

                            responder: BaseSocketSetSendBufferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x78a52fd9c7b2410b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::GetSendBuffer {
                            responder: BaseSocketGetSendBufferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6b0cf2f1919c7001 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetReceiveBufferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::SetReceiveBuffer {
                            value_bytes: req.value_bytes,

                            responder: BaseSocketSetReceiveBufferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x14c1a4b64f709e5c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::GetReceiveBuffer {
                            responder: BaseSocketGetReceiveBufferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x572df8f0b920d2c7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetKeepAliveRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::SetKeepAlive {
                            value: req.value,

                            responder: BaseSocketSetKeepAliveResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2dd29d3215f2c9d2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::GetKeepAlive {
                            responder: BaseSocketGetKeepAliveResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3ecb49968bee439 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetOutOfBandInlineRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::SetOutOfBandInline {
                            value: req.value,

                            responder: BaseSocketSetOutOfBandInlineResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x348c1ab3aeca1745 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::GetOutOfBandInline {
                            responder: BaseSocketGetOutOfBandInlineResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6bbf00c53a4c78c2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetNoCheckRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::SetNoCheck {
                            value: req.value,

                            responder: BaseSocketSetNoCheckResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2cd4249286417694 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::GetNoCheck {
                            responder: BaseSocketGetNoCheckResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x45386351246e998e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetLingerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::SetLinger {
                            linger: req.linger,
                            length_secs: req.length_secs,

                            responder: BaseSocketSetLingerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x48eb20fc5ccb0e45 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::GetLinger {
                            responder: BaseSocketGetLingerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x24dd3e5cb36d9ccb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetReusePortRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::SetReusePort {
                            value: req.value,

                            responder: BaseSocketSetReusePortResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7a112c1ab54ff828 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::GetReusePort {
                            responder: BaseSocketGetReusePortResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x67ce6db6c2ec8966 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::GetAcceptConn {
                            responder: BaseSocketGetAcceptConnResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2118b483f28aafc4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetBindToDeviceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::SetBindToDevice {
                            value: req.value,

                            responder: BaseSocketSetBindToDeviceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1ab1fbf0ef7906c8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::GetBindToDevice {
                            responder: BaseSocketGetBindToDeviceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6e387a0def00821 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetBindToInterfaceIndexRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::SetBindToInterfaceIndex {
                            value: req.value,

                            responder: BaseSocketSetBindToInterfaceIndexResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x59c31dd3e3078295 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::GetBindToInterfaceIndex {
                            responder: BaseSocketGetBindToInterfaceIndexResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x285d6516c263d839 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetTimestampRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::SetTimestamp {
                            value: req.value,

                            responder: BaseSocketSetTimestampResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x49f2fffbbcc2bd27 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::GetTimestamp {
                            responder: BaseSocketGetTimestampResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6ead6de09f653236 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetMarkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::SetMark {
                            domain: req.domain,
                            mark: req.mark,

                            responder: BaseSocketSetMarkResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x57a2752c61d93d47 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketGetMarkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::GetMark {
                            domain: req.domain,

                            responder: BaseSocketGetMarkResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2c2f47fd8f924e52 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
                        Ok(BaseSocketRequest::GetCookie {
                            responder: BaseSocketGetCookieResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <BaseSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A socket.
#[derive(Debug)]
pub enum BaseSocketRequest {
    Clone {
        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
        control_handle: BaseSocketControlHandle,
    },
    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    Close {
        responder: BaseSocketCloseResponder,
    },
    Query {
        responder: BaseSocketQueryResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
    SetReuseAddress {
        value: bool,
        responder: BaseSocketSetReuseAddressResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
    GetReuseAddress {
        responder: BaseSocketGetReuseAddressResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_ERROR`.
    /// Returns the last error if there is an error set on the socket.
    GetError {
        responder: BaseSocketGetErrorResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
    SetBroadcast {
        value: bool,
        responder: BaseSocketSetBroadcastResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
    GetBroadcast {
        responder: BaseSocketGetBroadcastResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
    SetSendBuffer {
        value_bytes: u64,
        responder: BaseSocketSetSendBufferResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
    GetSendBuffer {
        responder: BaseSocketGetSendBufferResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
    SetReceiveBuffer {
        value_bytes: u64,
        responder: BaseSocketSetReceiveBufferResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
    GetReceiveBuffer {
        responder: BaseSocketGetReceiveBufferResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
    SetKeepAlive {
        value: bool,
        responder: BaseSocketSetKeepAliveResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
    GetKeepAlive {
        responder: BaseSocketGetKeepAliveResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
    SetOutOfBandInline {
        value: bool,
        responder: BaseSocketSetOutOfBandInlineResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
    GetOutOfBandInline {
        responder: BaseSocketGetOutOfBandInlineResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
    SetNoCheck {
        value: bool,
        responder: BaseSocketSetNoCheckResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
    GetNoCheck {
        responder: BaseSocketGetNoCheckResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_LINGER`.
    SetLinger {
        linger: bool,
        length_secs: u32,
        responder: BaseSocketSetLingerResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_LINGER`.
    GetLinger {
        responder: BaseSocketGetLingerResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
    SetReusePort {
        value: bool,
        responder: BaseSocketSetReusePortResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
    GetReusePort {
        responder: BaseSocketGetReusePortResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
    GetAcceptConn {
        responder: BaseSocketGetAcceptConnResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    SetBindToDevice {
        value: String,
        responder: BaseSocketSetBindToDeviceResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    GetBindToDevice {
        responder: BaseSocketGetBindToDeviceResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    /// If `value` is 0, this clears the bound interface.
    SetBindToInterfaceIndex {
        value: u64,
        responder: BaseSocketSetBindToInterfaceIndexResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    GetBindToInterfaceIndex {
        responder: BaseSocketGetBindToInterfaceIndexResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    SetTimestamp {
        value: TimestampOption,
        responder: BaseSocketSetTimestampResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    GetTimestamp {
        responder: BaseSocketGetTimestampResponder,
    },
    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be set independently in each domain.
    SetMark {
        domain: fidl_fuchsia_net::MarkDomain,
        mark: OptionalUint32,
        responder: BaseSocketSetMarkResponder,
    },
    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be retrieved independently in each domain.
    GetMark {
        domain: fidl_fuchsia_net::MarkDomain,
        responder: BaseSocketGetMarkResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
    GetCookie {
        responder: BaseSocketGetCookieResponder,
    },
}

impl BaseSocketRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_clone(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
        BaseSocketControlHandle,
    )> {
        if let BaseSocketRequest::Clone { request, control_handle } = self {
            Some((request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_close(self) -> Option<(BaseSocketCloseResponder)> {
        if let BaseSocketRequest::Close { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query(self) -> Option<(BaseSocketQueryResponder)> {
        if let BaseSocketRequest::Query { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_reuse_address(self) -> Option<(bool, BaseSocketSetReuseAddressResponder)> {
        if let BaseSocketRequest::SetReuseAddress { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_reuse_address(self) -> Option<(BaseSocketGetReuseAddressResponder)> {
        if let BaseSocketRequest::GetReuseAddress { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_error(self) -> Option<(BaseSocketGetErrorResponder)> {
        if let BaseSocketRequest::GetError { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_broadcast(self) -> Option<(bool, BaseSocketSetBroadcastResponder)> {
        if let BaseSocketRequest::SetBroadcast { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_broadcast(self) -> Option<(BaseSocketGetBroadcastResponder)> {
        if let BaseSocketRequest::GetBroadcast { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_send_buffer(self) -> Option<(u64, BaseSocketSetSendBufferResponder)> {
        if let BaseSocketRequest::SetSendBuffer { value_bytes, responder } = self {
            Some((value_bytes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_send_buffer(self) -> Option<(BaseSocketGetSendBufferResponder)> {
        if let BaseSocketRequest::GetSendBuffer { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_receive_buffer(self) -> Option<(u64, BaseSocketSetReceiveBufferResponder)> {
        if let BaseSocketRequest::SetReceiveBuffer { value_bytes, responder } = self {
            Some((value_bytes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_receive_buffer(self) -> Option<(BaseSocketGetReceiveBufferResponder)> {
        if let BaseSocketRequest::GetReceiveBuffer { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_keep_alive(self) -> Option<(bool, BaseSocketSetKeepAliveResponder)> {
        if let BaseSocketRequest::SetKeepAlive { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_keep_alive(self) -> Option<(BaseSocketGetKeepAliveResponder)> {
        if let BaseSocketRequest::GetKeepAlive { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_out_of_band_inline(
        self,
    ) -> Option<(bool, BaseSocketSetOutOfBandInlineResponder)> {
        if let BaseSocketRequest::SetOutOfBandInline { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_out_of_band_inline(self) -> Option<(BaseSocketGetOutOfBandInlineResponder)> {
        if let BaseSocketRequest::GetOutOfBandInline { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_no_check(self) -> Option<(bool, BaseSocketSetNoCheckResponder)> {
        if let BaseSocketRequest::SetNoCheck { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_no_check(self) -> Option<(BaseSocketGetNoCheckResponder)> {
        if let BaseSocketRequest::GetNoCheck { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_linger(self) -> Option<(bool, u32, BaseSocketSetLingerResponder)> {
        if let BaseSocketRequest::SetLinger { linger, length_secs, responder } = self {
            Some((linger, length_secs, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_linger(self) -> Option<(BaseSocketGetLingerResponder)> {
        if let BaseSocketRequest::GetLinger { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_reuse_port(self) -> Option<(bool, BaseSocketSetReusePortResponder)> {
        if let BaseSocketRequest::SetReusePort { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_reuse_port(self) -> Option<(BaseSocketGetReusePortResponder)> {
        if let BaseSocketRequest::GetReusePort { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_accept_conn(self) -> Option<(BaseSocketGetAcceptConnResponder)> {
        if let BaseSocketRequest::GetAcceptConn { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_bind_to_device(self) -> Option<(String, BaseSocketSetBindToDeviceResponder)> {
        if let BaseSocketRequest::SetBindToDevice { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_bind_to_device(self) -> Option<(BaseSocketGetBindToDeviceResponder)> {
        if let BaseSocketRequest::GetBindToDevice { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_bind_to_interface_index(
        self,
    ) -> Option<(u64, BaseSocketSetBindToInterfaceIndexResponder)> {
        if let BaseSocketRequest::SetBindToInterfaceIndex { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_bind_to_interface_index(
        self,
    ) -> Option<(BaseSocketGetBindToInterfaceIndexResponder)> {
        if let BaseSocketRequest::GetBindToInterfaceIndex { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_timestamp(self) -> Option<(TimestampOption, BaseSocketSetTimestampResponder)> {
        if let BaseSocketRequest::SetTimestamp { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_timestamp(self) -> Option<(BaseSocketGetTimestampResponder)> {
        if let BaseSocketRequest::GetTimestamp { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_mark(
        self,
    ) -> Option<(fidl_fuchsia_net::MarkDomain, OptionalUint32, BaseSocketSetMarkResponder)> {
        if let BaseSocketRequest::SetMark { domain, mark, responder } = self {
            Some((domain, mark, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_mark(
        self,
    ) -> Option<(fidl_fuchsia_net::MarkDomain, BaseSocketGetMarkResponder)> {
        if let BaseSocketRequest::GetMark { domain, responder } = self {
            Some((domain, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_cookie(self) -> Option<(BaseSocketGetCookieResponder)> {
        if let BaseSocketRequest::GetCookie { responder } = self { Some((responder)) } else { None }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            BaseSocketRequest::Clone { .. } => "clone",
            BaseSocketRequest::Close { .. } => "close",
            BaseSocketRequest::Query { .. } => "query",
            BaseSocketRequest::SetReuseAddress { .. } => "set_reuse_address",
            BaseSocketRequest::GetReuseAddress { .. } => "get_reuse_address",
            BaseSocketRequest::GetError { .. } => "get_error",
            BaseSocketRequest::SetBroadcast { .. } => "set_broadcast",
            BaseSocketRequest::GetBroadcast { .. } => "get_broadcast",
            BaseSocketRequest::SetSendBuffer { .. } => "set_send_buffer",
            BaseSocketRequest::GetSendBuffer { .. } => "get_send_buffer",
            BaseSocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
            BaseSocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
            BaseSocketRequest::SetKeepAlive { .. } => "set_keep_alive",
            BaseSocketRequest::GetKeepAlive { .. } => "get_keep_alive",
            BaseSocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
            BaseSocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
            BaseSocketRequest::SetNoCheck { .. } => "set_no_check",
            BaseSocketRequest::GetNoCheck { .. } => "get_no_check",
            BaseSocketRequest::SetLinger { .. } => "set_linger",
            BaseSocketRequest::GetLinger { .. } => "get_linger",
            BaseSocketRequest::SetReusePort { .. } => "set_reuse_port",
            BaseSocketRequest::GetReusePort { .. } => "get_reuse_port",
            BaseSocketRequest::GetAcceptConn { .. } => "get_accept_conn",
            BaseSocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
            BaseSocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
            BaseSocketRequest::SetBindToInterfaceIndex { .. } => "set_bind_to_interface_index",
            BaseSocketRequest::GetBindToInterfaceIndex { .. } => "get_bind_to_interface_index",
            BaseSocketRequest::SetTimestamp { .. } => "set_timestamp",
            BaseSocketRequest::GetTimestamp { .. } => "get_timestamp",
            BaseSocketRequest::SetMark { .. } => "set_mark",
            BaseSocketRequest::GetMark { .. } => "get_mark",
            BaseSocketRequest::GetCookie { .. } => "get_cookie",
        }
    }
}

#[derive(Debug, Clone)]
pub struct BaseSocketControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for BaseSocketControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl BaseSocketControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketCloseResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketCloseResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketCloseResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketCloseResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
                result,
                self.tx_id,
                0x5ac5d459ad7f657e,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketQueryResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketQueryResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketQueryResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketQueryResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(protocol);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(protocol);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
            (protocol,),
            self.tx_id,
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketSetReuseAddressResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketSetReuseAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketSetReuseAddressResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketSetReuseAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x1fd74ee8b9a4a876,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketGetReuseAddressResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketGetReuseAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketGetReuseAddressResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketGetReuseAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetReuseAddressResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x67b7206b8d1bc0a5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketGetErrorResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketGetErrorResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketGetErrorResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketGetErrorResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x5aad39b33e5f6ebb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketSetBroadcastResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketSetBroadcastResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketSetBroadcastResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketSetBroadcastResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6023e081ce3cd947,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketGetBroadcastResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketGetBroadcastResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketGetBroadcastResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketGetBroadcastResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetBroadcastResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x68796fc556f9780d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketSetSendBufferResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketSetSendBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketSetSendBufferResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketSetSendBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x756eac32d73a7a70,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketGetSendBufferResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketGetSendBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketGetSendBufferResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketGetSendBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetSendBufferResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value_bytes| (value_bytes,)),
            self.tx_id,
            0x78a52fd9c7b2410b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketSetReceiveBufferResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketSetReceiveBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketSetReceiveBufferResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketSetReceiveBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6b0cf2f1919c7001,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketGetReceiveBufferResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketGetReceiveBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketGetReceiveBufferResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketGetReceiveBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetReceiveBufferResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value_bytes| (value_bytes,)),
            self.tx_id,
            0x14c1a4b64f709e5c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketSetKeepAliveResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketSetKeepAliveResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketSetKeepAliveResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketSetKeepAliveResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x572df8f0b920d2c7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketGetKeepAliveResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketGetKeepAliveResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketGetKeepAliveResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketGetKeepAliveResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetKeepAliveResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2dd29d3215f2c9d2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketSetOutOfBandInlineResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketSetOutOfBandInlineResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketSetOutOfBandInlineResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketSetOutOfBandInlineResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x3ecb49968bee439,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketGetOutOfBandInlineResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketGetOutOfBandInlineResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketGetOutOfBandInlineResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketGetOutOfBandInlineResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetOutOfBandInlineResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x348c1ab3aeca1745,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketSetNoCheckResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketSetNoCheckResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketSetNoCheckResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketSetNoCheckResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6bbf00c53a4c78c2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketGetNoCheckResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketGetNoCheckResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketGetNoCheckResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketGetNoCheckResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetNoCheckResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2cd4249286417694,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketSetLingerResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketSetLingerResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketSetLingerResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketSetLingerResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x45386351246e998e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketGetLingerResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketGetLingerResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketGetLingerResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketGetLingerResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetLingerResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x48eb20fc5ccb0e45,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketSetReusePortResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketSetReusePortResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketSetReusePortResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketSetReusePortResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x24dd3e5cb36d9ccb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketGetReusePortResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketGetReusePortResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketGetReusePortResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketGetReusePortResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetReusePortResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x7a112c1ab54ff828,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketGetAcceptConnResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketGetAcceptConnResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketGetAcceptConnResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketGetAcceptConnResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetAcceptConnResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x67ce6db6c2ec8966,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketSetBindToDeviceResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketSetBindToDeviceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketSetBindToDeviceResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketSetBindToDeviceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x2118b483f28aafc4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketGetBindToDeviceResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketGetBindToDeviceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketGetBindToDeviceResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketGetBindToDeviceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetBindToDeviceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x1ab1fbf0ef7906c8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketSetBindToInterfaceIndexResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketSetBindToInterfaceIndexResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketSetBindToInterfaceIndexResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketSetBindToInterfaceIndexResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6e387a0def00821,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketGetBindToInterfaceIndexResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketGetBindToInterfaceIndexResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketGetBindToInterfaceIndexResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketGetBindToInterfaceIndexResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetBindToInterfaceIndexResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x59c31dd3e3078295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketSetTimestampResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketSetTimestampResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketSetTimestampResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketSetTimestampResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x285d6516c263d839,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketGetTimestampResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketGetTimestampResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketGetTimestampResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketGetTimestampResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetTimestampResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x49f2fffbbcc2bd27,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketSetMarkResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketSetMarkResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketSetMarkResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketSetMarkResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6ead6de09f653236,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketGetMarkResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketGetMarkResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketGetMarkResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketGetMarkResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetMarkResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|mark| (mark,)),
            self.tx_id,
            0x57a2752c61d93d47,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct BaseSocketGetCookieResponder {
    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for BaseSocketGetCookieResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for BaseSocketGetCookieResponder {
    type ControlHandle = BaseSocketControlHandle;

    fn control_handle(&self) -> &BaseSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl BaseSocketGetCookieResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetCookieResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2c2f47fd8f924e52,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct DatagramSocketMarker;

impl fidl::endpoints::ProtocolMarker for DatagramSocketMarker {
    type Proxy = DatagramSocketProxy;
    type RequestStream = DatagramSocketRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DatagramSocketSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.posix.socket.DatagramSocket";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DatagramSocketMarker {}
pub type DatagramSocketSendMsgPreflightResult =
    Result<DatagramSocketSendMsgPreflightResponse, fidl_fuchsia_posix::Errno>;
pub type DatagramSocketRecvMsgPostflightResult =
    Result<DatagramSocketRecvMsgPostflightResponse, fidl_fuchsia_posix::Errno>;

pub trait DatagramSocketProxyInterface: Send + Sync {
    fn r#clone(
        &self,
        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error>;
    type CloseResponseFut: std::future::Future<
            Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
        > + Send;
    fn r#close(&self) -> Self::CloseResponseFut;
    type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
    fn r#query(&self) -> Self::QueryResponseFut;
    type SetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketSetReuseAddressResult, fidl::Error>>
        + Send;
    fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
    type GetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketGetReuseAddressResult, fidl::Error>>
        + Send;
    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
    type GetErrorResponseFut: std::future::Future<Output = Result<BaseSocketGetErrorResult, fidl::Error>>
        + Send;
    fn r#get_error(&self) -> Self::GetErrorResponseFut;
    type SetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketSetBroadcastResult, fidl::Error>>
        + Send;
    fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
    type GetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketGetBroadcastResult, fidl::Error>>
        + Send;
    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
    type SetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetSendBufferResult, fidl::Error>>
        + Send;
    fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
    type GetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetSendBufferResult, fidl::Error>>
        + Send;
    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
    type SetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetReceiveBufferResult, fidl::Error>>
        + Send;
    fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
    type GetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetReceiveBufferResult, fidl::Error>>
        + Send;
    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
    type SetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketSetKeepAliveResult, fidl::Error>>
        + Send;
    fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
    type GetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketGetKeepAliveResult, fidl::Error>>
        + Send;
    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
    type SetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketSetOutOfBandInlineResult, fidl::Error>>
        + Send;
    fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
    type GetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketGetOutOfBandInlineResult, fidl::Error>>
        + Send;
    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
    type SetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketSetNoCheckResult, fidl::Error>>
        + Send;
    fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
    type GetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketGetNoCheckResult, fidl::Error>>
        + Send;
    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
    type SetLingerResponseFut: std::future::Future<Output = Result<BaseSocketSetLingerResult, fidl::Error>>
        + Send;
    fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
    type GetLingerResponseFut: std::future::Future<Output = Result<BaseSocketGetLingerResult, fidl::Error>>
        + Send;
    fn r#get_linger(&self) -> Self::GetLingerResponseFut;
    type SetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketSetReusePortResult, fidl::Error>>
        + Send;
    fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
    type GetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketGetReusePortResult, fidl::Error>>
        + Send;
    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
    type GetAcceptConnResponseFut: std::future::Future<Output = Result<BaseSocketGetAcceptConnResult, fidl::Error>>
        + Send;
    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
    type SetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToDeviceResult, fidl::Error>>
        + Send;
    fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
    type GetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToDeviceResult, fidl::Error>>
        + Send;
    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
    type SetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error>>
        + Send;
    fn r#set_bind_to_interface_index(&self, value: u64)
    -> Self::SetBindToInterfaceIndexResponseFut;
    type GetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error>>
        + Send;
    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
    type SetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketSetTimestampResult, fidl::Error>>
        + Send;
    fn r#set_timestamp(&self, value: TimestampOption) -> Self::SetTimestampResponseFut;
    type GetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketGetTimestampResult, fidl::Error>>
        + Send;
    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
    type SetMarkResponseFut: std::future::Future<Output = Result<BaseSocketSetMarkResult, fidl::Error>>
        + Send;
    fn r#set_mark(
        &self,
        domain: fidl_fuchsia_net::MarkDomain,
        mark: &OptionalUint32,
    ) -> Self::SetMarkResponseFut;
    type GetMarkResponseFut: std::future::Future<Output = Result<BaseSocketGetMarkResult, fidl::Error>>
        + Send;
    fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
    type GetCookieResponseFut: std::future::Future<Output = Result<BaseSocketGetCookieResult, fidl::Error>>
        + Send;
    fn r#get_cookie(&self) -> Self::GetCookieResponseFut;
    type BindResponseFut: std::future::Future<Output = Result<BaseNetworkSocketBindResult, fidl::Error>>
        + Send;
    fn r#bind(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut;
    type ConnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketConnectResult, fidl::Error>>
        + Send;
    fn r#connect(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut;
    type DisconnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDisconnectResult, fidl::Error>>
        + Send;
    fn r#disconnect(&self) -> Self::DisconnectResponseFut;
    type GetSockNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetSockNameResult, fidl::Error>>
        + Send;
    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut;
    type GetPeerNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetPeerNameResult, fidl::Error>>
        + Send;
    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut;
    type ShutdownResponseFut: std::future::Future<Output = Result<BaseNetworkSocketShutdownResult, fidl::Error>>
        + Send;
    fn r#shutdown(&self, mode: ShutdownMode) -> Self::ShutdownResponseFut;
    type SetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>>
        + Send;
    fn r#set_ip_type_of_service(&self, value: u8) -> Self::SetIpTypeOfServiceResponseFut;
    type GetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>>
        + Send;
    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut;
    type SetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTtlResult, fidl::Error>>
        + Send;
    fn r#set_ip_ttl(&self, value: &OptionalUint8) -> Self::SetIpTtlResponseFut;
    type GetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTtlResult, fidl::Error>>
        + Send;
    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut;
    type SetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>>
        + Send;
    fn r#set_ip_packet_info(&self, value: bool) -> Self::SetIpPacketInfoResponseFut;
    type GetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>>
        + Send;
    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut;
    type SetIpReceiveTypeOfServiceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error>,
        > + Send;
    fn r#set_ip_receive_type_of_service(
        &self,
        value: bool,
    ) -> Self::SetIpReceiveTypeOfServiceResponseFut;
    type GetIpReceiveTypeOfServiceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error>,
        > + Send;
    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut;
    type SetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>>
        + Send;
    fn r#set_ip_receive_ttl(&self, value: bool) -> Self::SetIpReceiveTtlResponseFut;
    type GetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>>
        + Send;
    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut;
    type SetIpMulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#set_ip_multicast_interface(
        &self,
        iface: u64,
        address: &fidl_fuchsia_net::Ipv4Address,
    ) -> Self::SetIpMulticastInterfaceResponseFut;
    type GetIpMulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut;
    type SetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>>
        + Send;
    fn r#set_ip_multicast_ttl(&self, value: &OptionalUint8) -> Self::SetIpMulticastTtlResponseFut;
    type GetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>>
        + Send;
    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut;
    type SetIpMulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#set_ip_multicast_loopback(&self, value: bool) -> Self::SetIpMulticastLoopbackResponseFut;
    type GetIpMulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut;
    type AddIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error>>
        + Send;
    fn r#add_ip_membership(
        &self,
        membership: &IpMulticastMembership,
    ) -> Self::AddIpMembershipResponseFut;
    type DropIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error>>
        + Send;
    fn r#drop_ip_membership(
        &self,
        membership: &IpMulticastMembership,
    ) -> Self::DropIpMembershipResponseFut;
    type SetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error>>
        + Send;
    fn r#set_ip_transparent(&self, value: bool) -> Self::SetIpTransparentResponseFut;
    type GetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error>>
        + Send;
    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut;
    type SetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
            Output = Result<
                BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
                fidl::Error,
            >,
        > + Send;
    fn r#set_ip_receive_original_destination_address(
        &self,
        value: bool,
    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut;
    type GetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
            Output = Result<
                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
                fidl::Error,
            >,
        > + Send;
    fn r#get_ip_receive_original_destination_address(
        &self,
    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut;
    type AddIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>>
        + Send;
    fn r#add_ipv6_membership(
        &self,
        membership: &Ipv6MulticastMembership,
    ) -> Self::AddIpv6MembershipResponseFut;
    type DropIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>>
        + Send;
    fn r#drop_ipv6_membership(
        &self,
        membership: &Ipv6MulticastMembership,
    ) -> Self::DropIpv6MembershipResponseFut;
    type SetIpv6MulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_multicast_interface(
        &self,
        value: u64,
    ) -> Self::SetIpv6MulticastInterfaceResponseFut;
    type GetIpv6MulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut;
    type SetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>>
        + Send;
    fn r#set_ipv6_unicast_hops(&self, value: &OptionalUint8)
    -> Self::SetIpv6UnicastHopsResponseFut;
    type GetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>>
        + Send;
    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut;
    type SetIpv6ReceiveHopLimitResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_receive_hop_limit(&self, value: bool) -> Self::SetIpv6ReceiveHopLimitResponseFut;
    type GetIpv6ReceiveHopLimitResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut;
    type SetIpv6MulticastHopsResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_multicast_hops(
        &self,
        value: &OptionalUint8,
    ) -> Self::SetIpv6MulticastHopsResponseFut;
    type GetIpv6MulticastHopsResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut;
    type SetIpv6MulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_multicast_loopback(
        &self,
        value: bool,
    ) -> Self::SetIpv6MulticastLoopbackResponseFut;
    type GetIpv6MulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut;
    type SetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error>>
        + Send;
    fn r#set_ipv6_only(&self, value: bool) -> Self::SetIpv6OnlyResponseFut;
    type GetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error>>
        + Send;
    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut;
    type SetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_receive_traffic_class(
        &self,
        value: bool,
    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut;
    type GetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut;
    type SetIpv6TrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_traffic_class(
        &self,
        value: &OptionalUint8,
    ) -> Self::SetIpv6TrafficClassResponseFut;
    type GetIpv6TrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut;
    type SetIpv6ReceivePacketInfoResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_receive_packet_info(
        &self,
        value: bool,
    ) -> Self::SetIpv6ReceivePacketInfoResponseFut;
    type GetIpv6ReceivePacketInfoResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut;
    type GetOriginalDestinationResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error>,
        > + Send;
    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut;
    type GetInfoResponseFut: std::future::Future<Output = Result<BaseDatagramSocketGetInfoResult, fidl::Error>>
        + Send;
    fn r#get_info(&self) -> Self::GetInfoResponseFut;
    type DescribeResponseFut: std::future::Future<Output = Result<DatagramSocketDescribeResponse, fidl::Error>>
        + Send;
    fn r#describe(&self) -> Self::DescribeResponseFut;
    type SendMsgPreflightResponseFut: std::future::Future<Output = Result<DatagramSocketSendMsgPreflightResult, fidl::Error>>
        + Send;
    fn r#send_msg_preflight(
        &self,
        payload: &DatagramSocketSendMsgPreflightRequest,
    ) -> Self::SendMsgPreflightResponseFut;
    type RecvMsgPostflightResponseFut: std::future::Future<Output = Result<DatagramSocketRecvMsgPostflightResult, fidl::Error>>
        + Send;
    fn r#recv_msg_postflight(&self) -> Self::RecvMsgPostflightResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DatagramSocketSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DatagramSocketSynchronousProxy {
    type Proxy = DatagramSocketProxy;
    type Protocol = DatagramSocketMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl DatagramSocketSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <DatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<DatagramSocketEvent, fidl::Error> {
        DatagramSocketEvent::decode(self.client.wait_for_event(deadline)?)
    }

    pub fn r#clone(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_unknown::QueryableQueryResponse,
        >(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.protocol)
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#set_reuse_address(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetReuseAddressRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x1fd74ee8b9a4a876,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#get_reuse_address(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetReuseAddressResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Get `SOL_SOCKET` -> `SO_ERROR`.
    /// Returns the last error if there is an error set on the socket.
    pub fn r#get_error(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x5aad39b33e5f6ebb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#set_broadcast(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetBroadcastRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x6023e081ce3cd947,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#get_broadcast(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetBroadcastResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x68796fc556f9780d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#set_send_buffer(
        &self,
        mut value_bytes: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetSendBufferRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value_bytes,),
                0x756eac32d73a7a70,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#get_send_buffer(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetSendBufferResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value_bytes))
    }

    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#set_receive_buffer(
        &self,
        mut value_bytes: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseSocketSetReceiveBufferRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value_bytes,),
                    0x6b0cf2f1919c7001,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#get_receive_buffer(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetReceiveBufferResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value_bytes))
    }

    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#set_keep_alive(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetKeepAliveRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x572df8f0b920d2c7,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#get_keep_alive(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetKeepAliveResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x2dd29d3215f2c9d2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#set_out_of_band_inline(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseSocketSetOutOfBandInlineRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x3ecb49968bee439,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#get_out_of_band_inline(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetOutOfBandInlineResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#set_no_check(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetNoCheckRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x6bbf00c53a4c78c2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#get_no_check(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetNoCheckResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x2cd4249286417694,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#set_linger(
        &self,
        mut linger: bool,
        mut length_secs: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetLingerRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (linger, length_secs),
                0x45386351246e998e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#get_linger(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetLingerResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x48eb20fc5ccb0e45,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| (x.linger, x.length_secs)))
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#set_reuse_port(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetReusePortRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x24dd3e5cb36d9ccb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#get_reuse_port(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetReusePortResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x7a112c1ab54ff828,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
    pub fn r#get_accept_conn(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetAcceptConnResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#set_bind_to_device(
        &self,
        mut value: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetBindToDeviceRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x2118b483f28aafc4,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#get_bind_to_device(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetBindToDeviceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    /// If `value` is 0, this clears the bound interface.
    pub fn r#set_bind_to_interface_index(
        &self,
        mut value: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x6e387a0def00821,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    pub fn r#get_bind_to_interface_index(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetBindToInterfaceIndexResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#set_timestamp(
        &self,
        mut value: TimestampOption,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetTimestampRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x285d6516c263d839,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#get_timestamp(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetTimestampResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x49f2fffbbcc2bd27,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be set independently in each domain.
    pub fn r#set_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        mut mark: &OptionalUint32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetMarkRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (domain, mark),
                0x6ead6de09f653236,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be retrieved independently in each domain.
    pub fn r#get_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketGetMarkRequest, fidl::encoding::ResultType<
                BaseSocketGetMarkResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (domain,),
                0x57a2752c61d93d47,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.mark))
    }

    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
    pub fn r#get_cookie(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetCookieResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetCookieResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x2c2f47fd8f924e52,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Sets the local address used for the socket.
    pub fn r#bind(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketBindRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (addr,),
                0x4bc6400ae92125d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Initiates a connection to a remote address.
    pub fn r#connect(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketConnectRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (addr,),
                0x5f05f19bfdd38871,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Clears connection information from this socket.
    pub fn r#disconnect(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x74e63b91f7b29b2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Retrieves the local socket address.
    pub fn r#get_sock_name(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetSockNameResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x475f23f84a1a4f85, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.addr))
    }

    /// Retrieves the remote socket address.
    pub fn r#get_peer_name(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetPeerNameResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x1ffecf4bd5b6432e, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.addr))
    }

    /// Shuts down part of the socket.
    pub fn r#shutdown(
        &self,
        mut mode: ShutdownMode,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketShutdownRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (mode,),
                0x247f38b6db68c336,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IP` -> `IP_TOS`.
    pub fn r#set_ip_type_of_service(
        &self,
        mut value: u8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpTypeOfServiceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x995c600475b6d46,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_TOS`.
    pub fn r#get_ip_type_of_service(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpTypeOfServiceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x3814a04259f75fcb, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_TTL`.
    pub fn r#set_ip_ttl(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketSetIpTtlRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x29e2424b433ae1ef,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_TTL`.
    pub fn r#get_ip_ttl(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpTtlResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x47e47fa1f24da471, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#set_ip_packet_info(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x392d16bee20c0e16,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#get_ip_packet_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpPacketInfoResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x54b505f242280740, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#set_ip_receive_type_of_service(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x6c4f6714995f84ef,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#get_ip_receive_type_of_service(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4158ba7dc2795960, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#set_ip_receive_ttl(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x46f15be0ce0ab82b,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#get_ip_receive_ttl(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpReceiveTtlResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x678ddd5a5dfa2eb5, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#set_ip_multicast_interface(
        &self,
        mut iface: u64,
        mut address: &fidl_fuchsia_net::Ipv4Address,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpMulticastInterfaceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (iface, address,),
            0x752fbfa9b12befe,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#get_ip_multicast_interface(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpMulticastInterfaceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x320bd14c4df046c4, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#set_ip_multicast_ttl(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x63134d53772916a1,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#get_ip_multicast_ttl(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpMulticastTtlResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4665cd378f39e1a, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#set_ip_multicast_loopback(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpMulticastLoopbackRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x20c55c11f00943ea,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#get_ip_multicast_loopback(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpMulticastLoopbackResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x3b6b26ff558298f2, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
    pub fn r#add_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (membership,),
                    0x76bc7df115a3b4d0,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
    pub fn r#drop_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (membership,),
                    0x2888f3099188d03,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#set_ip_transparent(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x1ae532b0c066e3a0,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#get_ip_transparent(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpTransparentResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x51d43695962ebfb5, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#set_ip_receive_original_destination_address(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x4722b4ce52f7840,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#get_ip_receive_original_destination_address(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x2a0e7dc5d6bfdfe9, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
    pub fn r#add_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (membership,),
                    0x7c94727acb4ea4b3,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
    pub fn r#drop_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketDropIpv6MembershipRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (membership,),
            0x42104c70ccaba304,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#set_ipv6_multicast_interface(
        &self,
        mut value: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x135f76db3774ab3b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#get_ipv6_multicast_interface(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x1f26fcdd348f1882, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#set_ipv6_unicast_hops(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6UnicastHopsRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x157d51e98f462859,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#get_ipv6_unicast_hops(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6UnicastHopsResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x21f4641cad8bd8d2, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#set_ipv6_receive_hop_limit(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x5c24808ed2e84a1e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#get_ipv6_receive_hop_limit(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x341e06689885b4c0, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#set_ipv6_multicast_hops(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6MulticastHopsRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x25b9cd4d181f82c1,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#get_ipv6_multicast_hops(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6MulticastHopsResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x52916948a365012a, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#set_ipv6_multicast_loopback(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x55701c409ff41b40,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#get_ipv6_multicast_loopback(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4415b701fde319c3, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#set_ipv6_only(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x4873f1364758cbba,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#get_ipv6_only(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6OnlyResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4aa3340a1a26b89c, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#set_ipv6_receive_traffic_class(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x58f07c8788d099a0,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#get_ipv6_receive_traffic_class(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x2e334df1da553ffa, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
    pub fn r#set_ipv6_traffic_class(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6TrafficClassRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x6af077800c5a0b4f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
    pub fn r#get_ipv6_traffic_class(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6TrafficClassResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x6baf6eed8fc2f04, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#set_ipv6_receive_packet_info(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x19259775b1a92768,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#get_ipv6_receive_packet_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x7acd4a2775baec75, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
    pub fn r#get_original_destination(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetOriginalDestinationResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x38bf28f0dafdbac0, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Retrieves creation information from the socket.
    ///
    /// - response `domain` the socket's associated domain.
    /// - response `proto` the socket's associated protocol.
    pub fn r#get_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseDatagramSocketGetInfoResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseDatagramSocketGetInfoResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x48aa0a1f6a32d2ed, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| (x.domain, x.proto)))
    }

    pub fn r#describe(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DatagramSocketDescribeResponse, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, DatagramSocketDescribeResponse>(
                (),
                0xbf1e2f0a86601f3,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Validates that data can be sent.
    ///
    /// + request `args` the requested disposition of data to be sent.
    /// - response the constraints sent data must satisfy.
    /// * error the error code indicating the reason for validation failure.
    pub fn r#send_msg_preflight(
        &self,
        mut payload: &DatagramSocketSendMsgPreflightRequest,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DatagramSocketSendMsgPreflightResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<DatagramSocketSendMsgPreflightRequest, fidl::encoding::ResultType<
                DatagramSocketSendMsgPreflightResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                payload, 0x5362e668e777248a, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x))
    }

    /// Returns the set of requested control messages.
    ///
    /// - response the set of currently requested control messages.
    pub fn r#recv_msg_postflight(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<DatagramSocketRecvMsgPostflightResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                DatagramSocketRecvMsgPostflightResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x1a7cdeca5f3eb8e2, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x))
    }
}

#[cfg(target_os = "fuchsia")]
impl From<DatagramSocketSynchronousProxy> for zx::Handle {
    fn from(value: DatagramSocketSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for DatagramSocketSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for DatagramSocketSynchronousProxy {
    type Protocol = DatagramSocketMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<DatagramSocketMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct DatagramSocketProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for DatagramSocketProxy {
    type Protocol = DatagramSocketMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl DatagramSocketProxy {
    /// Create a new Proxy for fuchsia.posix.socket/DatagramSocket.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> DatagramSocketEventStream {
        DatagramSocketEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#clone(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        DatagramSocketProxyInterface::r#clone(self, request)
    }

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#close(self)
    }

    pub fn r#query(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        DatagramSocketProxyInterface::r#query(self)
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#set_reuse_address(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_reuse_address(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#get_reuse_address(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_reuse_address(self)
    }

    /// Get `SOL_SOCKET` -> `SO_ERROR`.
    /// Returns the last error if there is an error set on the socket.
    pub fn r#get_error(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetErrorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_error(self)
    }

    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#set_broadcast(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_broadcast(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#get_broadcast(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_broadcast(self)
    }

    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#set_send_buffer(
        &self,
        mut value_bytes: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_send_buffer(self, value_bytes)
    }

    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#get_send_buffer(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_send_buffer(self)
    }

    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#set_receive_buffer(
        &self,
        mut value_bytes: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_receive_buffer(self, value_bytes)
    }

    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#get_receive_buffer(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_receive_buffer(self)
    }

    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#set_keep_alive(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_keep_alive(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#get_keep_alive(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_keep_alive(self)
    }

    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#set_out_of_band_inline(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_out_of_band_inline(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#get_out_of_band_inline(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_out_of_band_inline(self)
    }

    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#set_no_check(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_no_check(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#get_no_check(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_no_check(self)
    }

    /// Set `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#set_linger(
        &self,
        mut linger: bool,
        mut length_secs: u32,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_linger(self, linger, length_secs)
    }

    /// Get `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#get_linger(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_linger(self)
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#set_reuse_port(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_reuse_port(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#get_reuse_port(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_reuse_port(self)
    }

    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
    pub fn r#get_accept_conn(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetAcceptConnResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_accept_conn(self)
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#set_bind_to_device(
        &self,
        mut value: &str,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_bind_to_device(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#get_bind_to_device(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_bind_to_device(self)
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    /// If `value` is 0, this clears the bound interface.
    pub fn r#set_bind_to_interface_index(
        &self,
        mut value: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_bind_to_interface_index(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    pub fn r#get_bind_to_interface_index(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_bind_to_interface_index(self)
    }

    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#set_timestamp(
        &self,
        mut value: TimestampOption,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_timestamp(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#get_timestamp(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_timestamp(self)
    }

    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be set independently in each domain.
    pub fn r#set_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        mut mark: &OptionalUint32,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_mark(self, domain, mark)
    }

    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be retrieved independently in each domain.
    pub fn r#get_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_mark(self, domain)
    }

    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
    pub fn r#get_cookie(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetCookieResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_cookie(self)
    }

    /// Sets the local address used for the socket.
    pub fn r#bind(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketBindResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#bind(self, addr)
    }

    /// Initiates a connection to a remote address.
    pub fn r#connect(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#connect(self, addr)
    }

    /// Clears connection information from this socket.
    pub fn r#disconnect(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketDisconnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#disconnect(self)
    }

    /// Retrieves the local socket address.
    pub fn r#get_sock_name(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetSockNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_sock_name(self)
    }

    /// Retrieves the remote socket address.
    pub fn r#get_peer_name(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetPeerNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_peer_name(self)
    }

    /// Shuts down part of the socket.
    pub fn r#shutdown(
        &self,
        mut mode: ShutdownMode,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketShutdownResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#shutdown(self, mode)
    }

    /// Set `SOL_IP` -> `IP_TOS`.
    pub fn r#set_ip_type_of_service(
        &self,
        mut value: u8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ip_type_of_service(self, value)
    }

    /// Get `SOL_IP` -> `IP_TOS`.
    pub fn r#get_ip_type_of_service(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ip_type_of_service(self)
    }

    /// Set `SOL_IP` -> `IP_TTL`.
    pub fn r#set_ip_ttl(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ip_ttl(self, value)
    }

    /// Get `SOL_IP` -> `IP_TTL`.
    pub fn r#get_ip_ttl(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ip_ttl(self)
    }

    /// Set `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#set_ip_packet_info(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ip_packet_info(self, value)
    }

    /// Get `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#get_ip_packet_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ip_packet_info(self)
    }

    /// Set `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#set_ip_receive_type_of_service(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ip_receive_type_of_service(self, value)
    }

    /// Get `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#get_ip_receive_type_of_service(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ip_receive_type_of_service(self)
    }

    /// Set `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#set_ip_receive_ttl(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ip_receive_ttl(self, value)
    }

    /// Get `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#get_ip_receive_ttl(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ip_receive_ttl(self)
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#set_ip_multicast_interface(
        &self,
        mut iface: u64,
        mut address: &fidl_fuchsia_net::Ipv4Address,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ip_multicast_interface(self, iface, address)
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#get_ip_multicast_interface(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ip_multicast_interface(self)
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#set_ip_multicast_ttl(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ip_multicast_ttl(self, value)
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#get_ip_multicast_ttl(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ip_multicast_ttl(self)
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#set_ip_multicast_loopback(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ip_multicast_loopback(self, value)
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#get_ip_multicast_loopback(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ip_multicast_loopback(self)
    }

    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
    pub fn r#add_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#add_ip_membership(self, membership)
    }

    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
    pub fn r#drop_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#drop_ip_membership(self, membership)
    }

    /// Set `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#set_ip_transparent(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ip_transparent(self, value)
    }

    /// Get `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#get_ip_transparent(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ip_transparent(self)
    }

    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#set_ip_receive_original_destination_address(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ip_receive_original_destination_address(self, value)
    }

    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#get_ip_receive_original_destination_address(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ip_receive_original_destination_address(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
    pub fn r#add_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#add_ipv6_membership(self, membership)
    }

    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
    pub fn r#drop_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#drop_ipv6_membership(self, membership)
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#set_ipv6_multicast_interface(
        &self,
        mut value: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ipv6_multicast_interface(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#get_ipv6_multicast_interface(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ipv6_multicast_interface(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#set_ipv6_unicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ipv6_unicast_hops(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#get_ipv6_unicast_hops(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ipv6_unicast_hops(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#set_ipv6_receive_hop_limit(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ipv6_receive_hop_limit(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#get_ipv6_receive_hop_limit(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ipv6_receive_hop_limit(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#set_ipv6_multicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ipv6_multicast_hops(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#get_ipv6_multicast_hops(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ipv6_multicast_hops(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#set_ipv6_multicast_loopback(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ipv6_multicast_loopback(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#get_ipv6_multicast_loopback(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ipv6_multicast_loopback(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#set_ipv6_only(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ipv6_only(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#get_ipv6_only(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ipv6_only(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#set_ipv6_receive_traffic_class(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ipv6_receive_traffic_class(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#get_ipv6_receive_traffic_class(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ipv6_receive_traffic_class(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
    pub fn r#set_ipv6_traffic_class(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ipv6_traffic_class(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
    pub fn r#get_ipv6_traffic_class(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ipv6_traffic_class(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#set_ipv6_receive_packet_info(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#set_ipv6_receive_packet_info(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#get_ipv6_receive_packet_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_ipv6_receive_packet_info(self)
    }

    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
    pub fn r#get_original_destination(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetOriginalDestinationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_original_destination(self)
    }

    /// Retrieves creation information from the socket.
    ///
    /// - response `domain` the socket's associated domain.
    /// - response `proto` the socket's associated protocol.
    pub fn r#get_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseDatagramSocketGetInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#get_info(self)
    }

    pub fn r#describe(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DatagramSocketDescribeResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#describe(self)
    }

    /// Validates that data can be sent.
    ///
    /// + request `args` the requested disposition of data to be sent.
    /// - response the constraints sent data must satisfy.
    /// * error the error code indicating the reason for validation failure.
    pub fn r#send_msg_preflight(
        &self,
        mut payload: &DatagramSocketSendMsgPreflightRequest,
    ) -> fidl::client::QueryResponseFut<
        DatagramSocketSendMsgPreflightResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#send_msg_preflight(self, payload)
    }

    /// Returns the set of requested control messages.
    ///
    /// - response the set of currently requested control messages.
    pub fn r#recv_msg_postflight(
        &self,
    ) -> fidl::client::QueryResponseFut<
        DatagramSocketRecvMsgPostflightResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        DatagramSocketProxyInterface::r#recv_msg_postflight(self)
    }
}

impl DatagramSocketProxyInterface for DatagramSocketProxy {
    fn r#clone(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type CloseResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#close(&self) -> Self::CloseResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5ac5d459ad7f657e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_unknown::CloseableCloseResult,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryResponseFut =
        fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#query(&self) -> Self::QueryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<u8>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl_fuchsia_unknown::QueryableQueryResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2658edee9decfc06,
            >(_buf?)?;
            Ok(_response.protocol)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1fd74ee8b9a4a876,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetReuseAddressRequest,
            BaseSocketSetReuseAddressResult,
        >(
            (value,),
            0x1fd74ee8b9a4a876,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetReuseAddressResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x67b7206b8d1bc0a5,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReuseAddressResult>(
                (),
                0x67b7206b8d1bc0a5,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetErrorResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetErrorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_error(&self) -> Self::GetErrorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5aad39b33e5f6ebb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetErrorResult>(
            (),
            0x5aad39b33e5f6ebb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6023e081ce3cd947,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetBroadcastRequest, BaseSocketSetBroadcastResult>(
                (value,),
                0x6023e081ce3cd947,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetBroadcastResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x68796fc556f9780d,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBroadcastResult>(
                (),
                0x68796fc556f9780d,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x756eac32d73a7a70,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetSendBufferRequest, BaseSocketSetSendBufferResult>(
                (value_bytes,),
                0x756eac32d73a7a70,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetSendBufferResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x78a52fd9c7b2410b,
            >(_buf?)?;
            Ok(_response.map(|x| x.value_bytes))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetSendBufferResult>(
                (),
                0x78a52fd9c7b2410b,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6b0cf2f1919c7001,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetReceiveBufferRequest,
            BaseSocketSetReceiveBufferResult,
        >(
            (value_bytes,),
            0x6b0cf2f1919c7001,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetReceiveBufferResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x14c1a4b64f709e5c,
            >(_buf?)?;
            Ok(_response.map(|x| x.value_bytes))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseSocketGetReceiveBufferResult,
        >(
            (),
            0x14c1a4b64f709e5c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x572df8f0b920d2c7,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetKeepAliveRequest, BaseSocketSetKeepAliveResult>(
                (value,),
                0x572df8f0b920d2c7,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetKeepAliveResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2dd29d3215f2c9d2,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetKeepAliveResult>(
                (),
                0x2dd29d3215f2c9d2,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3ecb49968bee439,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetOutOfBandInlineRequest,
            BaseSocketSetOutOfBandInlineResult,
        >(
            (value,),
            0x3ecb49968bee439,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetOutOfBandInlineResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x348c1ab3aeca1745,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseSocketGetOutOfBandInlineResult,
        >(
            (),
            0x348c1ab3aeca1745,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6bbf00c53a4c78c2,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetNoCheckRequest, BaseSocketSetNoCheckResult>(
                (value,),
                0x6bbf00c53a4c78c2,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetNoCheckResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2cd4249286417694,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetNoCheckResult>(
                (),
                0x2cd4249286417694,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetLingerResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x45386351246e998e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<BaseSocketSetLingerRequest, BaseSocketSetLingerResult>(
            (linger, length_secs),
            0x45386351246e998e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetLingerResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_linger(&self) -> Self::GetLingerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetLingerResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x48eb20fc5ccb0e45,
            >(_buf?)?;
            Ok(_response.map(|x| (x.linger, x.length_secs)))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetLingerResult>(
                (),
                0x48eb20fc5ccb0e45,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetReusePortResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x24dd3e5cb36d9ccb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetReusePortRequest, BaseSocketSetReusePortResult>(
                (value,),
                0x24dd3e5cb36d9ccb,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetReusePortResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetReusePortResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7a112c1ab54ff828,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReusePortResult>(
                (),
                0x7a112c1ab54ff828,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetAcceptConnResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetAcceptConnResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x67ce6db6c2ec8966,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetAcceptConnResult>(
                (),
                0x67ce6db6c2ec8966,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2118b483f28aafc4,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetBindToDeviceRequest,
            BaseSocketSetBindToDeviceResult,
        >(
            (value,),
            0x2118b483f28aafc4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetBindToDeviceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ab1fbf0ef7906c8,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBindToDeviceResult>(
                (),
                0x1ab1fbf0ef7906c8,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_bind_to_interface_index(
        &self,
        mut value: u64,
    ) -> Self::SetBindToInterfaceIndexResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6e387a0def00821,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetBindToInterfaceIndexRequest,
            BaseSocketSetBindToInterfaceIndexResult,
        >(
            (value,),
            0x6e387a0def00821,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetBindToInterfaceIndexResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x59c31dd3e3078295,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseSocketGetBindToInterfaceIndexResult,
        >(
            (),
            0x59c31dd3e3078295,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetTimestampResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_timestamp(&self, mut value: TimestampOption) -> Self::SetTimestampResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x285d6516c263d839,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetTimestampRequest, BaseSocketSetTimestampResult>(
                (value,),
                0x285d6516c263d839,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetTimestampResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetTimestampResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x49f2fffbbcc2bd27,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetTimestampResult>(
                (),
                0x49f2fffbbcc2bd27,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetMarkResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        mut mark: &OptionalUint32,
    ) -> Self::SetMarkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6ead6de09f653236,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<BaseSocketSetMarkRequest, BaseSocketSetMarkResult>(
            (domain, mark),
            0x6ead6de09f653236,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetMarkResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x57a2752c61d93d47,
            >(_buf?)?;
            Ok(_response.map(|x| x.mark))
        }
        self.client.send_query_and_decode::<BaseSocketGetMarkRequest, BaseSocketGetMarkResult>(
            (domain,),
            0x57a2752c61d93d47,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetCookieResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetCookieResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_cookie(&self) -> Self::GetCookieResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetCookieResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetCookieResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2c2f47fd8f924e52,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetCookieResult>(
                (),
                0x2c2f47fd8f924e52,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type BindResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketBindResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#bind(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4bc6400ae92125d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseNetworkSocketBindRequest, BaseNetworkSocketBindResult>(
                (addr,),
                0x4bc6400ae92125d,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ConnectResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5f05f19bfdd38871,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketConnectRequest,
            BaseNetworkSocketConnectResult,
        >(
            (addr,),
            0x5f05f19bfdd38871,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DisconnectResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketDisconnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#disconnect(&self) -> Self::DisconnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x74e63b91f7b29b2,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketDisconnectResult,
        >(
            (),
            0x74e63b91f7b29b2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetSockNameResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetSockNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetSockNameResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x475f23f84a1a4f85,
            >(_buf?)?;
            Ok(_response.map(|x| x.addr))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetSockNameResult,
        >(
            (),
            0x475f23f84a1a4f85,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetPeerNameResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetPeerNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetPeerNameResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ffecf4bd5b6432e,
            >(_buf?)?;
            Ok(_response.map(|x| x.addr))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetPeerNameResult,
        >(
            (),
            0x1ffecf4bd5b6432e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ShutdownResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketShutdownResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#shutdown(&self, mut mode: ShutdownMode) -> Self::ShutdownResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x247f38b6db68c336,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketShutdownRequest,
            BaseNetworkSocketShutdownResult,
        >(
            (mode,),
            0x247f38b6db68c336,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_type_of_service(&self, mut value: u8) -> Self::SetIpTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x995c600475b6d46,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpTypeOfServiceRequest,
            BaseNetworkSocketSetIpTypeOfServiceResult,
        >(
            (value,),
            0x995c600475b6d46,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpTypeOfServiceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3814a04259f75fcb,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpTypeOfServiceResult,
        >(
            (),
            0x3814a04259f75fcb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_ttl(&self, mut value: &OptionalUint8) -> Self::SetIpTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x29e2424b433ae1ef,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpTtlRequest,
            BaseNetworkSocketSetIpTtlResult,
        >(
            (value,),
            0x29e2424b433ae1ef,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpTtlResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x47e47fa1f24da471,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseNetworkSocketGetIpTtlResult>(
                (),
                0x47e47fa1f24da471,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_packet_info(&self, mut value: bool) -> Self::SetIpPacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x392d16bee20c0e16,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpPacketInfoRequest,
            BaseNetworkSocketSetIpPacketInfoResult,
        >(
            (value,),
            0x392d16bee20c0e16,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpPacketInfoResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x54b505f242280740,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpPacketInfoResult,
        >(
            (),
            0x54b505f242280740,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_receive_type_of_service(
        &self,
        mut value: bool,
    ) -> Self::SetIpReceiveTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6c4f6714995f84ef,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
            BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
        >(
            (value,),
            0x6c4f6714995f84ef,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4158ba7dc2795960,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
        >(
            (),
            0x4158ba7dc2795960,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_receive_ttl(&self, mut value: bool) -> Self::SetIpReceiveTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x46f15be0ce0ab82b,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpReceiveTtlRequest,
            BaseNetworkSocketSetIpReceiveTtlResult,
        >(
            (value,),
            0x46f15be0ce0ab82b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpReceiveTtlResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x678ddd5a5dfa2eb5,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpReceiveTtlResult,
        >(
            (),
            0x678ddd5a5dfa2eb5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_multicast_interface(
        &self,
        mut iface: u64,
        mut address: &fidl_fuchsia_net::Ipv4Address,
    ) -> Self::SetIpMulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x752fbfa9b12befe,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpMulticastInterfaceRequest,
            BaseNetworkSocketSetIpMulticastInterfaceResult,
        >(
            (iface, address,),
            0x752fbfa9b12befe,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpMulticastInterfaceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x320bd14c4df046c4,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpMulticastInterfaceResult,
        >(
            (),
            0x320bd14c4df046c4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_multicast_ttl(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpMulticastTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x63134d53772916a1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpMulticastTtlRequest,
            BaseNetworkSocketSetIpMulticastTtlResult,
        >(
            (value,),
            0x63134d53772916a1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpMulticastTtlResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4665cd378f39e1a,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpMulticastTtlResult,
        >(
            (),
            0x4665cd378f39e1a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_multicast_loopback(
        &self,
        mut value: bool,
    ) -> Self::SetIpMulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x20c55c11f00943ea,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpMulticastLoopbackRequest,
            BaseNetworkSocketSetIpMulticastLoopbackResult,
        >(
            (value,),
            0x20c55c11f00943ea,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpMulticastLoopbackResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3b6b26ff558298f2,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpMulticastLoopbackResult,
        >(
            (),
            0x3b6b26ff558298f2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddIpMembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> Self::AddIpMembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x76bc7df115a3b4d0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketAddIpMembershipRequest,
            BaseNetworkSocketAddIpMembershipResult,
        >(
            (membership,),
            0x76bc7df115a3b4d0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DropIpMembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#drop_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> Self::DropIpMembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2888f3099188d03,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketDropIpMembershipRequest,
            BaseNetworkSocketDropIpMembershipResult,
        >(
            (membership,),
            0x2888f3099188d03,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpTransparentResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_transparent(&self, mut value: bool) -> Self::SetIpTransparentResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ae532b0c066e3a0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpTransparentRequest,
            BaseNetworkSocketSetIpTransparentResult,
        >(
            (value,),
            0x1ae532b0c066e3a0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpTransparentResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpTransparentResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x51d43695962ebfb5,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpTransparentResult,
        >(
            (),
            0x51d43695962ebfb5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_receive_original_destination_address(
        &self,
        mut value: bool,
    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4722b4ce52f7840,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
        >(
            (value,),
            0x4722b4ce52f7840,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_receive_original_destination_address(
        &self,
    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2a0e7dc5d6bfdfe9,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
        >(
            (),
            0x2a0e7dc5d6bfdfe9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> Self::AddIpv6MembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7c94727acb4ea4b3,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketAddIpv6MembershipRequest,
            BaseNetworkSocketAddIpv6MembershipResult,
        >(
            (membership,),
            0x7c94727acb4ea4b3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DropIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#drop_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> Self::DropIpv6MembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x42104c70ccaba304,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketDropIpv6MembershipRequest,
            BaseNetworkSocketDropIpv6MembershipResult,
        >(
            (membership,),
            0x42104c70ccaba304,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_multicast_interface(
        &self,
        mut value: u64,
    ) -> Self::SetIpv6MulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x135f76db3774ab3b,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
            BaseNetworkSocketSetIpv6MulticastInterfaceResult,
        >(
            (value,),
            0x135f76db3774ab3b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1f26fcdd348f1882,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6MulticastInterfaceResult,
        >(
            (),
            0x1f26fcdd348f1882,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_unicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpv6UnicastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x157d51e98f462859,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6UnicastHopsRequest,
            BaseNetworkSocketSetIpv6UnicastHopsResult,
        >(
            (value,),
            0x157d51e98f462859,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6UnicastHopsResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x21f4641cad8bd8d2,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6UnicastHopsResult,
        >(
            (),
            0x21f4641cad8bd8d2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_receive_hop_limit(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6ReceiveHopLimitResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5c24808ed2e84a1e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
            BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
        >(
            (value,),
            0x5c24808ed2e84a1e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x341e06689885b4c0,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
        >(
            (),
            0x341e06689885b4c0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_multicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpv6MulticastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x25b9cd4d181f82c1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6MulticastHopsRequest,
            BaseNetworkSocketSetIpv6MulticastHopsResult,
        >(
            (value,),
            0x25b9cd4d181f82c1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6MulticastHopsResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x52916948a365012a,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6MulticastHopsResult,
        >(
            (),
            0x52916948a365012a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_multicast_loopback(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6MulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x55701c409ff41b40,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
            BaseNetworkSocketSetIpv6MulticastLoopbackResult,
        >(
            (value,),
            0x55701c409ff41b40,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4415b701fde319c3,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6MulticastLoopbackResult,
        >(
            (),
            0x4415b701fde319c3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_only(&self, mut value: bool) -> Self::SetIpv6OnlyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4873f1364758cbba,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6OnlyRequest,
            BaseNetworkSocketSetIpv6OnlyResult,
        >(
            (value,),
            0x4873f1364758cbba,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6OnlyResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4aa3340a1a26b89c,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6OnlyResult,
        >(
            (),
            0x4aa3340a1a26b89c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_receive_traffic_class(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x58f07c8788d099a0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
            BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
        >(
            (value,),
            0x58f07c8788d099a0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2e334df1da553ffa,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
        >(
            (),
            0x2e334df1da553ffa,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_traffic_class(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpv6TrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6af077800c5a0b4f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6TrafficClassRequest,
            BaseNetworkSocketSetIpv6TrafficClassResult,
        >(
            (value,),
            0x6af077800c5a0b4f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6TrafficClassResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6baf6eed8fc2f04,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6TrafficClassResult,
        >(
            (),
            0x6baf6eed8fc2f04,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_receive_packet_info(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6ReceivePacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x19259775b1a92768,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
            BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
        >(
            (value,),
            0x19259775b1a92768,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7acd4a2775baec75,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
        >(
            (),
            0x7acd4a2775baec75,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetOriginalDestinationResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetOriginalDestinationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetOriginalDestinationResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x38bf28f0dafdbac0,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetOriginalDestinationResult,
        >(
            (),
            0x38bf28f0dafdbac0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetInfoResponseFut = fidl::client::QueryResponseFut<
        BaseDatagramSocketGetInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_info(&self) -> Self::GetInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseDatagramSocketGetInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseDatagramSocketGetInfoResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x48aa0a1f6a32d2ed,
            >(_buf?)?;
            Ok(_response.map(|x| (x.domain, x.proto)))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseDatagramSocketGetInfoResult>(
                (),
                0x48aa0a1f6a32d2ed,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type DescribeResponseFut = fidl::client::QueryResponseFut<
        DatagramSocketDescribeResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#describe(&self) -> Self::DescribeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DatagramSocketDescribeResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                DatagramSocketDescribeResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xbf1e2f0a86601f3,
            >(_buf?)?;
            Ok(_response)
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, DatagramSocketDescribeResponse>(
                (),
                0xbf1e2f0a86601f3,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SendMsgPreflightResponseFut = fidl::client::QueryResponseFut<
        DatagramSocketSendMsgPreflightResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#send_msg_preflight(
        &self,
        mut payload: &DatagramSocketSendMsgPreflightRequest,
    ) -> Self::SendMsgPreflightResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DatagramSocketSendMsgPreflightResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    DatagramSocketSendMsgPreflightResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5362e668e777248a,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            DatagramSocketSendMsgPreflightRequest,
            DatagramSocketSendMsgPreflightResult,
        >(
            payload,
            0x5362e668e777248a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RecvMsgPostflightResponseFut = fidl::client::QueryResponseFut<
        DatagramSocketRecvMsgPostflightResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#recv_msg_postflight(&self) -> Self::RecvMsgPostflightResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<DatagramSocketRecvMsgPostflightResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    DatagramSocketRecvMsgPostflightResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1a7cdeca5f3eb8e2,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            DatagramSocketRecvMsgPostflightResult,
        >(
            (),
            0x1a7cdeca5f3eb8e2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct DatagramSocketEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for DatagramSocketEventStream {}

impl futures::stream::FusedStream for DatagramSocketEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for DatagramSocketEventStream {
    type Item = Result<DatagramSocketEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(DatagramSocketEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum DatagramSocketEvent {}

impl DatagramSocketEvent {
    /// Decodes a message buffer as a [`DatagramSocketEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<DatagramSocketEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <DatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.posix.socket/DatagramSocket.
pub struct DatagramSocketRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for DatagramSocketRequestStream {}

impl futures::stream::FusedStream for DatagramSocketRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for DatagramSocketRequestStream {
    type Protocol = DatagramSocketMarker;
    type ControlHandle = DatagramSocketControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        DatagramSocketControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for DatagramSocketRequestStream {
    type Item = Result<DatagramSocketRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled DatagramSocketRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x20d8a7aba2168a79 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl_fuchsia_unknown::CloneableCloneRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::Clone { request: req.request, control_handle })
                    }
                    0x5ac5d459ad7f657e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::Close {
                            responder: DatagramSocketCloseResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2658edee9decfc06 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::Query {
                            responder: DatagramSocketQueryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1fd74ee8b9a4a876 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetReuseAddressRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetReuseAddress {
                            value: req.value,

                            responder: DatagramSocketSetReuseAddressResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x67b7206b8d1bc0a5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetReuseAddress {
                            responder: DatagramSocketGetReuseAddressResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5aad39b33e5f6ebb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetError {
                            responder: DatagramSocketGetErrorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6023e081ce3cd947 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetBroadcastRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetBroadcast {
                            value: req.value,

                            responder: DatagramSocketSetBroadcastResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x68796fc556f9780d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetBroadcast {
                            responder: DatagramSocketGetBroadcastResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x756eac32d73a7a70 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetSendBufferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetSendBuffer {
                            value_bytes: req.value_bytes,

                            responder: DatagramSocketSetSendBufferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x78a52fd9c7b2410b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetSendBuffer {
                            responder: DatagramSocketGetSendBufferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6b0cf2f1919c7001 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetReceiveBufferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetReceiveBuffer {
                            value_bytes: req.value_bytes,

                            responder: DatagramSocketSetReceiveBufferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x14c1a4b64f709e5c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetReceiveBuffer {
                            responder: DatagramSocketGetReceiveBufferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x572df8f0b920d2c7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetKeepAliveRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetKeepAlive {
                            value: req.value,

                            responder: DatagramSocketSetKeepAliveResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2dd29d3215f2c9d2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetKeepAlive {
                            responder: DatagramSocketGetKeepAliveResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3ecb49968bee439 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetOutOfBandInlineRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetOutOfBandInline {
                            value: req.value,

                            responder: DatagramSocketSetOutOfBandInlineResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x348c1ab3aeca1745 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetOutOfBandInline {
                            responder: DatagramSocketGetOutOfBandInlineResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6bbf00c53a4c78c2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetNoCheckRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetNoCheck {
                            value: req.value,

                            responder: DatagramSocketSetNoCheckResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2cd4249286417694 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetNoCheck {
                            responder: DatagramSocketGetNoCheckResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x45386351246e998e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetLingerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetLinger {
                            linger: req.linger,
                            length_secs: req.length_secs,

                            responder: DatagramSocketSetLingerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x48eb20fc5ccb0e45 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetLinger {
                            responder: DatagramSocketGetLingerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x24dd3e5cb36d9ccb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetReusePortRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetReusePort {
                            value: req.value,

                            responder: DatagramSocketSetReusePortResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7a112c1ab54ff828 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetReusePort {
                            responder: DatagramSocketGetReusePortResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x67ce6db6c2ec8966 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetAcceptConn {
                            responder: DatagramSocketGetAcceptConnResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2118b483f28aafc4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetBindToDeviceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetBindToDevice {
                            value: req.value,

                            responder: DatagramSocketSetBindToDeviceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1ab1fbf0ef7906c8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetBindToDevice {
                            responder: DatagramSocketGetBindToDeviceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6e387a0def00821 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetBindToInterfaceIndexRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetBindToInterfaceIndex {
                            value: req.value,

                            responder: DatagramSocketSetBindToInterfaceIndexResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x59c31dd3e3078295 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetBindToInterfaceIndex {
                            responder: DatagramSocketGetBindToInterfaceIndexResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x285d6516c263d839 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetTimestampRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetTimestamp {
                            value: req.value,

                            responder: DatagramSocketSetTimestampResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x49f2fffbbcc2bd27 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetTimestamp {
                            responder: DatagramSocketGetTimestampResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6ead6de09f653236 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetMarkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetMark {
                            domain: req.domain,
                            mark: req.mark,

                            responder: DatagramSocketSetMarkResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x57a2752c61d93d47 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketGetMarkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetMark {
                            domain: req.domain,

                            responder: DatagramSocketGetMarkResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2c2f47fd8f924e52 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetCookie {
                            responder: DatagramSocketGetCookieResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4bc6400ae92125d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketBindRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketBindRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::Bind {
                            addr: req.addr,

                            responder: DatagramSocketBindResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5f05f19bfdd38871 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::Connect {
                            addr: req.addr,

                            responder: DatagramSocketConnectResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x74e63b91f7b29b2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::Disconnect {
                            responder: DatagramSocketDisconnectResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x475f23f84a1a4f85 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetSockName {
                            responder: DatagramSocketGetSockNameResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1ffecf4bd5b6432e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetPeerName {
                            responder: DatagramSocketGetPeerNameResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x247f38b6db68c336 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketShutdownRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketShutdownRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::Shutdown {
                            mode: req.mode,

                            responder: DatagramSocketShutdownResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x995c600475b6d46 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpTypeOfServiceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpTypeOfService {
                            value: req.value,

                            responder: DatagramSocketSetIpTypeOfServiceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3814a04259f75fcb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpTypeOfService {
                            responder: DatagramSocketGetIpTypeOfServiceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x29e2424b433ae1ef => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpTtlRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTtlRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpTtl {
                            value: req.value,

                            responder: DatagramSocketSetIpTtlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x47e47fa1f24da471 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpTtl {
                            responder: DatagramSocketGetIpTtlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x392d16bee20c0e16 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpPacketInfoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpPacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpPacketInfo {
                            value: req.value,

                            responder: DatagramSocketSetIpPacketInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x54b505f242280740 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpPacketInfo {
                            responder: DatagramSocketGetIpPacketInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6c4f6714995f84ef => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpReceiveTypeOfService {
                            value: req.value,

                            responder: DatagramSocketSetIpReceiveTypeOfServiceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4158ba7dc2795960 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpReceiveTypeOfService {
                            responder: DatagramSocketGetIpReceiveTypeOfServiceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x46f15be0ce0ab82b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpReceiveTtlRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTtlRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpReceiveTtl {
                            value: req.value,

                            responder: DatagramSocketSetIpReceiveTtlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x678ddd5a5dfa2eb5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpReceiveTtl {
                            responder: DatagramSocketGetIpReceiveTtlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x752fbfa9b12befe => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpMulticastInterfaceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpMulticastInterface {
                            iface: req.iface,
                            address: req.address,

                            responder: DatagramSocketSetIpMulticastInterfaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x320bd14c4df046c4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpMulticastInterface {
                            responder: DatagramSocketGetIpMulticastInterfaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x63134d53772916a1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpMulticastTtlRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastTtlRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpMulticastTtl {
                            value: req.value,

                            responder: DatagramSocketSetIpMulticastTtlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4665cd378f39e1a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpMulticastTtl {
                            responder: DatagramSocketGetIpMulticastTtlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x20c55c11f00943ea => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpMulticastLoopbackRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpMulticastLoopback {
                            value: req.value,

                            responder: DatagramSocketSetIpMulticastLoopbackResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3b6b26ff558298f2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpMulticastLoopback {
                            responder: DatagramSocketGetIpMulticastLoopbackResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x76bc7df115a3b4d0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketAddIpMembershipRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::AddIpMembership {
                            membership: req.membership,

                            responder: DatagramSocketAddIpMembershipResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2888f3099188d03 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketDropIpMembershipRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::DropIpMembership {
                            membership: req.membership,

                            responder: DatagramSocketDropIpMembershipResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1ae532b0c066e3a0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpTransparentRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTransparentRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpTransparent {
                            value: req.value,

                            responder: DatagramSocketSetIpTransparentResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x51d43695962ebfb5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpTransparent {
                            responder: DatagramSocketGetIpTransparentResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4722b4ce52f7840 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpReceiveOriginalDestinationAddress {
                            value: req.value,

                            responder:
                                DatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
                                    control_handle: std::mem::ManuallyDrop::new(control_handle),
                                    tx_id: header.tx_id,
                                },
                        })
                    }
                    0x2a0e7dc5d6bfdfe9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpReceiveOriginalDestinationAddress {
                            responder:
                                DatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
                                    control_handle: std::mem::ManuallyDrop::new(control_handle),
                                    tx_id: header.tx_id,
                                },
                        })
                    }
                    0x7c94727acb4ea4b3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketAddIpv6MembershipRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::AddIpv6Membership {
                            membership: req.membership,

                            responder: DatagramSocketAddIpv6MembershipResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x42104c70ccaba304 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketDropIpv6MembershipRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::DropIpv6Membership {
                            membership: req.membership,

                            responder: DatagramSocketDropIpv6MembershipResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x135f76db3774ab3b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpv6MulticastInterface {
                            value: req.value,

                            responder: DatagramSocketSetIpv6MulticastInterfaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1f26fcdd348f1882 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpv6MulticastInterface {
                            responder: DatagramSocketGetIpv6MulticastInterfaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x157d51e98f462859 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6UnicastHopsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6UnicastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpv6UnicastHops {
                            value: req.value,

                            responder: DatagramSocketSetIpv6UnicastHopsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x21f4641cad8bd8d2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpv6UnicastHops {
                            responder: DatagramSocketGetIpv6UnicastHopsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5c24808ed2e84a1e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveHopLimitRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpv6ReceiveHopLimit {
                            value: req.value,

                            responder: DatagramSocketSetIpv6ReceiveHopLimitResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x341e06689885b4c0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpv6ReceiveHopLimit {
                            responder: DatagramSocketGetIpv6ReceiveHopLimitResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x25b9cd4d181f82c1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6MulticastHopsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpv6MulticastHops {
                            value: req.value,

                            responder: DatagramSocketSetIpv6MulticastHopsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x52916948a365012a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpv6MulticastHops {
                            responder: DatagramSocketGetIpv6MulticastHopsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x55701c409ff41b40 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpv6MulticastLoopback {
                            value: req.value,

                            responder: DatagramSocketSetIpv6MulticastLoopbackResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4415b701fde319c3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpv6MulticastLoopback {
                            responder: DatagramSocketGetIpv6MulticastLoopbackResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4873f1364758cbba => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6OnlyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6OnlyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpv6Only {
                            value: req.value,

                            responder: DatagramSocketSetIpv6OnlyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4aa3340a1a26b89c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpv6Only {
                            responder: DatagramSocketGetIpv6OnlyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x58f07c8788d099a0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpv6ReceiveTrafficClass {
                            value: req.value,

                            responder: DatagramSocketSetIpv6ReceiveTrafficClassResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2e334df1da553ffa => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpv6ReceiveTrafficClass {
                            responder: DatagramSocketGetIpv6ReceiveTrafficClassResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6af077800c5a0b4f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6TrafficClassRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6TrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpv6TrafficClass {
                            value: req.value,

                            responder: DatagramSocketSetIpv6TrafficClassResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6baf6eed8fc2f04 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpv6TrafficClass {
                            responder: DatagramSocketGetIpv6TrafficClassResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x19259775b1a92768 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceivePacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SetIpv6ReceivePacketInfo {
                            value: req.value,

                            responder: DatagramSocketSetIpv6ReceivePacketInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7acd4a2775baec75 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetIpv6ReceivePacketInfo {
                            responder: DatagramSocketGetIpv6ReceivePacketInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x38bf28f0dafdbac0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetOriginalDestination {
                            responder: DatagramSocketGetOriginalDestinationResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x48aa0a1f6a32d2ed => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::GetInfo {
                            responder: DatagramSocketGetInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xbf1e2f0a86601f3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::Describe {
                            responder: DatagramSocketDescribeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5362e668e777248a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DatagramSocketSendMsgPreflightRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DatagramSocketSendMsgPreflightRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::SendMsgPreflight {
                            payload: req,
                            responder: DatagramSocketSendMsgPreflightResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1a7cdeca5f3eb8e2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DatagramSocketControlHandle { inner: this.inner.clone() };
                        Ok(DatagramSocketRequest::RecvMsgPostflight {
                            responder: DatagramSocketRecvMsgPostflightResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A datagram socket.
#[derive(Debug)]
pub enum DatagramSocketRequest {
    Clone {
        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
        control_handle: DatagramSocketControlHandle,
    },
    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    Close {
        responder: DatagramSocketCloseResponder,
    },
    Query {
        responder: DatagramSocketQueryResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
    SetReuseAddress {
        value: bool,
        responder: DatagramSocketSetReuseAddressResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
    GetReuseAddress {
        responder: DatagramSocketGetReuseAddressResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_ERROR`.
    /// Returns the last error if there is an error set on the socket.
    GetError {
        responder: DatagramSocketGetErrorResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
    SetBroadcast {
        value: bool,
        responder: DatagramSocketSetBroadcastResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
    GetBroadcast {
        responder: DatagramSocketGetBroadcastResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
    SetSendBuffer {
        value_bytes: u64,
        responder: DatagramSocketSetSendBufferResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
    GetSendBuffer {
        responder: DatagramSocketGetSendBufferResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
    SetReceiveBuffer {
        value_bytes: u64,
        responder: DatagramSocketSetReceiveBufferResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
    GetReceiveBuffer {
        responder: DatagramSocketGetReceiveBufferResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
    SetKeepAlive {
        value: bool,
        responder: DatagramSocketSetKeepAliveResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
    GetKeepAlive {
        responder: DatagramSocketGetKeepAliveResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
    SetOutOfBandInline {
        value: bool,
        responder: DatagramSocketSetOutOfBandInlineResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
    GetOutOfBandInline {
        responder: DatagramSocketGetOutOfBandInlineResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
    SetNoCheck {
        value: bool,
        responder: DatagramSocketSetNoCheckResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
    GetNoCheck {
        responder: DatagramSocketGetNoCheckResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_LINGER`.
    SetLinger {
        linger: bool,
        length_secs: u32,
        responder: DatagramSocketSetLingerResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_LINGER`.
    GetLinger {
        responder: DatagramSocketGetLingerResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
    SetReusePort {
        value: bool,
        responder: DatagramSocketSetReusePortResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
    GetReusePort {
        responder: DatagramSocketGetReusePortResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
    GetAcceptConn {
        responder: DatagramSocketGetAcceptConnResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    SetBindToDevice {
        value: String,
        responder: DatagramSocketSetBindToDeviceResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    GetBindToDevice {
        responder: DatagramSocketGetBindToDeviceResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    /// If `value` is 0, this clears the bound interface.
    SetBindToInterfaceIndex {
        value: u64,
        responder: DatagramSocketSetBindToInterfaceIndexResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    GetBindToInterfaceIndex {
        responder: DatagramSocketGetBindToInterfaceIndexResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    SetTimestamp {
        value: TimestampOption,
        responder: DatagramSocketSetTimestampResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    GetTimestamp {
        responder: DatagramSocketGetTimestampResponder,
    },
    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be set independently in each domain.
    SetMark {
        domain: fidl_fuchsia_net::MarkDomain,
        mark: OptionalUint32,
        responder: DatagramSocketSetMarkResponder,
    },
    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be retrieved independently in each domain.
    GetMark {
        domain: fidl_fuchsia_net::MarkDomain,
        responder: DatagramSocketGetMarkResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
    GetCookie {
        responder: DatagramSocketGetCookieResponder,
    },
    /// Sets the local address used for the socket.
    Bind {
        addr: fidl_fuchsia_net::SocketAddress,
        responder: DatagramSocketBindResponder,
    },
    /// Initiates a connection to a remote address.
    Connect {
        addr: fidl_fuchsia_net::SocketAddress,
        responder: DatagramSocketConnectResponder,
    },
    /// Clears connection information from this socket.
    Disconnect {
        responder: DatagramSocketDisconnectResponder,
    },
    /// Retrieves the local socket address.
    GetSockName {
        responder: DatagramSocketGetSockNameResponder,
    },
    /// Retrieves the remote socket address.
    GetPeerName {
        responder: DatagramSocketGetPeerNameResponder,
    },
    /// Shuts down part of the socket.
    Shutdown {
        mode: ShutdownMode,
        responder: DatagramSocketShutdownResponder,
    },
    /// Set `SOL_IP` -> `IP_TOS`.
    SetIpTypeOfService {
        value: u8,
        responder: DatagramSocketSetIpTypeOfServiceResponder,
    },
    /// Get `SOL_IP` -> `IP_TOS`.
    GetIpTypeOfService {
        responder: DatagramSocketGetIpTypeOfServiceResponder,
    },
    /// Set `SOL_IP` -> `IP_TTL`.
    SetIpTtl {
        value: OptionalUint8,
        responder: DatagramSocketSetIpTtlResponder,
    },
    /// Get `SOL_IP` -> `IP_TTL`.
    GetIpTtl {
        responder: DatagramSocketGetIpTtlResponder,
    },
    /// Set `SOL_IP` -> `IP_PKTINFO`.
    SetIpPacketInfo {
        value: bool,
        responder: DatagramSocketSetIpPacketInfoResponder,
    },
    /// Get `SOL_IP` -> `IP_PKTINFO`.
    GetIpPacketInfo {
        responder: DatagramSocketGetIpPacketInfoResponder,
    },
    /// Set `SOL_IP` -> `IP_RECVTOS`.
    SetIpReceiveTypeOfService {
        value: bool,
        responder: DatagramSocketSetIpReceiveTypeOfServiceResponder,
    },
    /// Get `SOL_IP` -> `IP_RECVTOS`.
    GetIpReceiveTypeOfService {
        responder: DatagramSocketGetIpReceiveTypeOfServiceResponder,
    },
    /// Set `SOL_IP` -> `IP_RECVTTL`.
    SetIpReceiveTtl {
        value: bool,
        responder: DatagramSocketSetIpReceiveTtlResponder,
    },
    /// Get `SOL_IP` -> `IP_RECVTTL`.
    GetIpReceiveTtl {
        responder: DatagramSocketGetIpReceiveTtlResponder,
    },
    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
    SetIpMulticastInterface {
        iface: u64,
        address: fidl_fuchsia_net::Ipv4Address,
        responder: DatagramSocketSetIpMulticastInterfaceResponder,
    },
    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
    GetIpMulticastInterface {
        responder: DatagramSocketGetIpMulticastInterfaceResponder,
    },
    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
    SetIpMulticastTtl {
        value: OptionalUint8,
        responder: DatagramSocketSetIpMulticastTtlResponder,
    },
    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
    GetIpMulticastTtl {
        responder: DatagramSocketGetIpMulticastTtlResponder,
    },
    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
    SetIpMulticastLoopback {
        value: bool,
        responder: DatagramSocketSetIpMulticastLoopbackResponder,
    },
    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
    GetIpMulticastLoopback {
        responder: DatagramSocketGetIpMulticastLoopbackResponder,
    },
    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
    AddIpMembership {
        membership: IpMulticastMembership,
        responder: DatagramSocketAddIpMembershipResponder,
    },
    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
    DropIpMembership {
        membership: IpMulticastMembership,
        responder: DatagramSocketDropIpMembershipResponder,
    },
    /// Set `SOL_IP` -> `IP_TRANSPARENT`
    SetIpTransparent {
        value: bool,
        responder: DatagramSocketSetIpTransparentResponder,
    },
    /// Get `SOL_IP` -> `IP_TRANSPARENT`
    GetIpTransparent {
        responder: DatagramSocketGetIpTransparentResponder,
    },
    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
    SetIpReceiveOriginalDestinationAddress {
        value: bool,
        responder: DatagramSocketSetIpReceiveOriginalDestinationAddressResponder,
    },
    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
    GetIpReceiveOriginalDestinationAddress {
        responder: DatagramSocketGetIpReceiveOriginalDestinationAddressResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
    AddIpv6Membership {
        membership: Ipv6MulticastMembership,
        responder: DatagramSocketAddIpv6MembershipResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
    DropIpv6Membership {
        membership: Ipv6MulticastMembership,
        responder: DatagramSocketDropIpv6MembershipResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    SetIpv6MulticastInterface {
        value: u64,
        responder: DatagramSocketSetIpv6MulticastInterfaceResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    GetIpv6MulticastInterface {
        responder: DatagramSocketGetIpv6MulticastInterfaceResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    SetIpv6UnicastHops {
        value: OptionalUint8,
        responder: DatagramSocketSetIpv6UnicastHopsResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    GetIpv6UnicastHops {
        responder: DatagramSocketGetIpv6UnicastHopsResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    SetIpv6ReceiveHopLimit {
        value: bool,
        responder: DatagramSocketSetIpv6ReceiveHopLimitResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    GetIpv6ReceiveHopLimit {
        responder: DatagramSocketGetIpv6ReceiveHopLimitResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    SetIpv6MulticastHops {
        value: OptionalUint8,
        responder: DatagramSocketSetIpv6MulticastHopsResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    GetIpv6MulticastHops {
        responder: DatagramSocketGetIpv6MulticastHopsResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    SetIpv6MulticastLoopback {
        value: bool,
        responder: DatagramSocketSetIpv6MulticastLoopbackResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    GetIpv6MulticastLoopback {
        responder: DatagramSocketGetIpv6MulticastLoopbackResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
    SetIpv6Only {
        value: bool,
        responder: DatagramSocketSetIpv6OnlyResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
    GetIpv6Only {
        responder: DatagramSocketGetIpv6OnlyResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    SetIpv6ReceiveTrafficClass {
        value: bool,
        responder: DatagramSocketSetIpv6ReceiveTrafficClassResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    GetIpv6ReceiveTrafficClass {
        responder: DatagramSocketGetIpv6ReceiveTrafficClassResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
    SetIpv6TrafficClass {
        value: OptionalUint8,
        responder: DatagramSocketSetIpv6TrafficClassResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
    GetIpv6TrafficClass {
        responder: DatagramSocketGetIpv6TrafficClassResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    SetIpv6ReceivePacketInfo {
        value: bool,
        responder: DatagramSocketSetIpv6ReceivePacketInfoResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    GetIpv6ReceivePacketInfo {
        responder: DatagramSocketGetIpv6ReceivePacketInfoResponder,
    },
    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
    GetOriginalDestination {
        responder: DatagramSocketGetOriginalDestinationResponder,
    },
    /// Retrieves creation information from the socket.
    ///
    /// - response `domain` the socket's associated domain.
    /// - response `proto` the socket's associated protocol.
    GetInfo {
        responder: DatagramSocketGetInfoResponder,
    },
    Describe {
        responder: DatagramSocketDescribeResponder,
    },
    /// Validates that data can be sent.
    ///
    /// + request `args` the requested disposition of data to be sent.
    /// - response the constraints sent data must satisfy.
    /// * error the error code indicating the reason for validation failure.
    SendMsgPreflight {
        payload: DatagramSocketSendMsgPreflightRequest,
        responder: DatagramSocketSendMsgPreflightResponder,
    },
    /// Returns the set of requested control messages.
    ///
    /// - response the set of currently requested control messages.
    RecvMsgPostflight {
        responder: DatagramSocketRecvMsgPostflightResponder,
    },
}

impl DatagramSocketRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_clone(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
        DatagramSocketControlHandle,
    )> {
        if let DatagramSocketRequest::Clone { request, control_handle } = self {
            Some((request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_close(self) -> Option<(DatagramSocketCloseResponder)> {
        if let DatagramSocketRequest::Close { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query(self) -> Option<(DatagramSocketQueryResponder)> {
        if let DatagramSocketRequest::Query { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_reuse_address(self) -> Option<(bool, DatagramSocketSetReuseAddressResponder)> {
        if let DatagramSocketRequest::SetReuseAddress { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_reuse_address(self) -> Option<(DatagramSocketGetReuseAddressResponder)> {
        if let DatagramSocketRequest::GetReuseAddress { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_error(self) -> Option<(DatagramSocketGetErrorResponder)> {
        if let DatagramSocketRequest::GetError { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_broadcast(self) -> Option<(bool, DatagramSocketSetBroadcastResponder)> {
        if let DatagramSocketRequest::SetBroadcast { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_broadcast(self) -> Option<(DatagramSocketGetBroadcastResponder)> {
        if let DatagramSocketRequest::GetBroadcast { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_send_buffer(self) -> Option<(u64, DatagramSocketSetSendBufferResponder)> {
        if let DatagramSocketRequest::SetSendBuffer { value_bytes, responder } = self {
            Some((value_bytes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_send_buffer(self) -> Option<(DatagramSocketGetSendBufferResponder)> {
        if let DatagramSocketRequest::GetSendBuffer { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_receive_buffer(self) -> Option<(u64, DatagramSocketSetReceiveBufferResponder)> {
        if let DatagramSocketRequest::SetReceiveBuffer { value_bytes, responder } = self {
            Some((value_bytes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_receive_buffer(self) -> Option<(DatagramSocketGetReceiveBufferResponder)> {
        if let DatagramSocketRequest::GetReceiveBuffer { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_keep_alive(self) -> Option<(bool, DatagramSocketSetKeepAliveResponder)> {
        if let DatagramSocketRequest::SetKeepAlive { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_keep_alive(self) -> Option<(DatagramSocketGetKeepAliveResponder)> {
        if let DatagramSocketRequest::GetKeepAlive { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_out_of_band_inline(
        self,
    ) -> Option<(bool, DatagramSocketSetOutOfBandInlineResponder)> {
        if let DatagramSocketRequest::SetOutOfBandInline { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_out_of_band_inline(
        self,
    ) -> Option<(DatagramSocketGetOutOfBandInlineResponder)> {
        if let DatagramSocketRequest::GetOutOfBandInline { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_no_check(self) -> Option<(bool, DatagramSocketSetNoCheckResponder)> {
        if let DatagramSocketRequest::SetNoCheck { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_no_check(self) -> Option<(DatagramSocketGetNoCheckResponder)> {
        if let DatagramSocketRequest::GetNoCheck { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_linger(self) -> Option<(bool, u32, DatagramSocketSetLingerResponder)> {
        if let DatagramSocketRequest::SetLinger { linger, length_secs, responder } = self {
            Some((linger, length_secs, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_linger(self) -> Option<(DatagramSocketGetLingerResponder)> {
        if let DatagramSocketRequest::GetLinger { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_reuse_port(self) -> Option<(bool, DatagramSocketSetReusePortResponder)> {
        if let DatagramSocketRequest::SetReusePort { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_reuse_port(self) -> Option<(DatagramSocketGetReusePortResponder)> {
        if let DatagramSocketRequest::GetReusePort { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_accept_conn(self) -> Option<(DatagramSocketGetAcceptConnResponder)> {
        if let DatagramSocketRequest::GetAcceptConn { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_bind_to_device(
        self,
    ) -> Option<(String, DatagramSocketSetBindToDeviceResponder)> {
        if let DatagramSocketRequest::SetBindToDevice { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_bind_to_device(self) -> Option<(DatagramSocketGetBindToDeviceResponder)> {
        if let DatagramSocketRequest::GetBindToDevice { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_bind_to_interface_index(
        self,
    ) -> Option<(u64, DatagramSocketSetBindToInterfaceIndexResponder)> {
        if let DatagramSocketRequest::SetBindToInterfaceIndex { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_bind_to_interface_index(
        self,
    ) -> Option<(DatagramSocketGetBindToInterfaceIndexResponder)> {
        if let DatagramSocketRequest::GetBindToInterfaceIndex { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_timestamp(
        self,
    ) -> Option<(TimestampOption, DatagramSocketSetTimestampResponder)> {
        if let DatagramSocketRequest::SetTimestamp { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_timestamp(self) -> Option<(DatagramSocketGetTimestampResponder)> {
        if let DatagramSocketRequest::GetTimestamp { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_mark(
        self,
    ) -> Option<(fidl_fuchsia_net::MarkDomain, OptionalUint32, DatagramSocketSetMarkResponder)>
    {
        if let DatagramSocketRequest::SetMark { domain, mark, responder } = self {
            Some((domain, mark, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_mark(
        self,
    ) -> Option<(fidl_fuchsia_net::MarkDomain, DatagramSocketGetMarkResponder)> {
        if let DatagramSocketRequest::GetMark { domain, responder } = self {
            Some((domain, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_cookie(self) -> Option<(DatagramSocketGetCookieResponder)> {
        if let DatagramSocketRequest::GetCookie { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind(
        self,
    ) -> Option<(fidl_fuchsia_net::SocketAddress, DatagramSocketBindResponder)> {
        if let DatagramSocketRequest::Bind { addr, responder } = self {
            Some((addr, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fidl_fuchsia_net::SocketAddress, DatagramSocketConnectResponder)> {
        if let DatagramSocketRequest::Connect { addr, responder } = self {
            Some((addr, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_disconnect(self) -> Option<(DatagramSocketDisconnectResponder)> {
        if let DatagramSocketRequest::Disconnect { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_sock_name(self) -> Option<(DatagramSocketGetSockNameResponder)> {
        if let DatagramSocketRequest::GetSockName { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_peer_name(self) -> Option<(DatagramSocketGetPeerNameResponder)> {
        if let DatagramSocketRequest::GetPeerName { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_shutdown(self) -> Option<(ShutdownMode, DatagramSocketShutdownResponder)> {
        if let DatagramSocketRequest::Shutdown { mode, responder } = self {
            Some((mode, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_type_of_service(
        self,
    ) -> Option<(u8, DatagramSocketSetIpTypeOfServiceResponder)> {
        if let DatagramSocketRequest::SetIpTypeOfService { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_type_of_service(
        self,
    ) -> Option<(DatagramSocketGetIpTypeOfServiceResponder)> {
        if let DatagramSocketRequest::GetIpTypeOfService { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_ttl(self) -> Option<(OptionalUint8, DatagramSocketSetIpTtlResponder)> {
        if let DatagramSocketRequest::SetIpTtl { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_ttl(self) -> Option<(DatagramSocketGetIpTtlResponder)> {
        if let DatagramSocketRequest::GetIpTtl { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_packet_info(self) -> Option<(bool, DatagramSocketSetIpPacketInfoResponder)> {
        if let DatagramSocketRequest::SetIpPacketInfo { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_packet_info(self) -> Option<(DatagramSocketGetIpPacketInfoResponder)> {
        if let DatagramSocketRequest::GetIpPacketInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_receive_type_of_service(
        self,
    ) -> Option<(bool, DatagramSocketSetIpReceiveTypeOfServiceResponder)> {
        if let DatagramSocketRequest::SetIpReceiveTypeOfService { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_receive_type_of_service(
        self,
    ) -> Option<(DatagramSocketGetIpReceiveTypeOfServiceResponder)> {
        if let DatagramSocketRequest::GetIpReceiveTypeOfService { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_receive_ttl(self) -> Option<(bool, DatagramSocketSetIpReceiveTtlResponder)> {
        if let DatagramSocketRequest::SetIpReceiveTtl { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_receive_ttl(self) -> Option<(DatagramSocketGetIpReceiveTtlResponder)> {
        if let DatagramSocketRequest::GetIpReceiveTtl { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_multicast_interface(
        self,
    ) -> Option<(u64, fidl_fuchsia_net::Ipv4Address, DatagramSocketSetIpMulticastInterfaceResponder)>
    {
        if let DatagramSocketRequest::SetIpMulticastInterface { iface, address, responder } = self {
            Some((iface, address, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_multicast_interface(
        self,
    ) -> Option<(DatagramSocketGetIpMulticastInterfaceResponder)> {
        if let DatagramSocketRequest::GetIpMulticastInterface { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_multicast_ttl(
        self,
    ) -> Option<(OptionalUint8, DatagramSocketSetIpMulticastTtlResponder)> {
        if let DatagramSocketRequest::SetIpMulticastTtl { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_multicast_ttl(self) -> Option<(DatagramSocketGetIpMulticastTtlResponder)> {
        if let DatagramSocketRequest::GetIpMulticastTtl { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_multicast_loopback(
        self,
    ) -> Option<(bool, DatagramSocketSetIpMulticastLoopbackResponder)> {
        if let DatagramSocketRequest::SetIpMulticastLoopback { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_multicast_loopback(
        self,
    ) -> Option<(DatagramSocketGetIpMulticastLoopbackResponder)> {
        if let DatagramSocketRequest::GetIpMulticastLoopback { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_ip_membership(
        self,
    ) -> Option<(IpMulticastMembership, DatagramSocketAddIpMembershipResponder)> {
        if let DatagramSocketRequest::AddIpMembership { membership, responder } = self {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_drop_ip_membership(
        self,
    ) -> Option<(IpMulticastMembership, DatagramSocketDropIpMembershipResponder)> {
        if let DatagramSocketRequest::DropIpMembership { membership, responder } = self {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_transparent(
        self,
    ) -> Option<(bool, DatagramSocketSetIpTransparentResponder)> {
        if let DatagramSocketRequest::SetIpTransparent { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_transparent(self) -> Option<(DatagramSocketGetIpTransparentResponder)> {
        if let DatagramSocketRequest::GetIpTransparent { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_receive_original_destination_address(
        self,
    ) -> Option<(bool, DatagramSocketSetIpReceiveOriginalDestinationAddressResponder)> {
        if let DatagramSocketRequest::SetIpReceiveOriginalDestinationAddress { value, responder } =
            self
        {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_receive_original_destination_address(
        self,
    ) -> Option<(DatagramSocketGetIpReceiveOriginalDestinationAddressResponder)> {
        if let DatagramSocketRequest::GetIpReceiveOriginalDestinationAddress { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_ipv6_membership(
        self,
    ) -> Option<(Ipv6MulticastMembership, DatagramSocketAddIpv6MembershipResponder)> {
        if let DatagramSocketRequest::AddIpv6Membership { membership, responder } = self {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_drop_ipv6_membership(
        self,
    ) -> Option<(Ipv6MulticastMembership, DatagramSocketDropIpv6MembershipResponder)> {
        if let DatagramSocketRequest::DropIpv6Membership { membership, responder } = self {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_multicast_interface(
        self,
    ) -> Option<(u64, DatagramSocketSetIpv6MulticastInterfaceResponder)> {
        if let DatagramSocketRequest::SetIpv6MulticastInterface { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_multicast_interface(
        self,
    ) -> Option<(DatagramSocketGetIpv6MulticastInterfaceResponder)> {
        if let DatagramSocketRequest::GetIpv6MulticastInterface { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_unicast_hops(
        self,
    ) -> Option<(OptionalUint8, DatagramSocketSetIpv6UnicastHopsResponder)> {
        if let DatagramSocketRequest::SetIpv6UnicastHops { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_unicast_hops(self) -> Option<(DatagramSocketGetIpv6UnicastHopsResponder)> {
        if let DatagramSocketRequest::GetIpv6UnicastHops { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_receive_hop_limit(
        self,
    ) -> Option<(bool, DatagramSocketSetIpv6ReceiveHopLimitResponder)> {
        if let DatagramSocketRequest::SetIpv6ReceiveHopLimit { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_receive_hop_limit(
        self,
    ) -> Option<(DatagramSocketGetIpv6ReceiveHopLimitResponder)> {
        if let DatagramSocketRequest::GetIpv6ReceiveHopLimit { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_multicast_hops(
        self,
    ) -> Option<(OptionalUint8, DatagramSocketSetIpv6MulticastHopsResponder)> {
        if let DatagramSocketRequest::SetIpv6MulticastHops { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_multicast_hops(
        self,
    ) -> Option<(DatagramSocketGetIpv6MulticastHopsResponder)> {
        if let DatagramSocketRequest::GetIpv6MulticastHops { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_multicast_loopback(
        self,
    ) -> Option<(bool, DatagramSocketSetIpv6MulticastLoopbackResponder)> {
        if let DatagramSocketRequest::SetIpv6MulticastLoopback { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_multicast_loopback(
        self,
    ) -> Option<(DatagramSocketGetIpv6MulticastLoopbackResponder)> {
        if let DatagramSocketRequest::GetIpv6MulticastLoopback { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_only(self) -> Option<(bool, DatagramSocketSetIpv6OnlyResponder)> {
        if let DatagramSocketRequest::SetIpv6Only { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_only(self) -> Option<(DatagramSocketGetIpv6OnlyResponder)> {
        if let DatagramSocketRequest::GetIpv6Only { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_receive_traffic_class(
        self,
    ) -> Option<(bool, DatagramSocketSetIpv6ReceiveTrafficClassResponder)> {
        if let DatagramSocketRequest::SetIpv6ReceiveTrafficClass { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_receive_traffic_class(
        self,
    ) -> Option<(DatagramSocketGetIpv6ReceiveTrafficClassResponder)> {
        if let DatagramSocketRequest::GetIpv6ReceiveTrafficClass { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_traffic_class(
        self,
    ) -> Option<(OptionalUint8, DatagramSocketSetIpv6TrafficClassResponder)> {
        if let DatagramSocketRequest::SetIpv6TrafficClass { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_traffic_class(
        self,
    ) -> Option<(DatagramSocketGetIpv6TrafficClassResponder)> {
        if let DatagramSocketRequest::GetIpv6TrafficClass { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_receive_packet_info(
        self,
    ) -> Option<(bool, DatagramSocketSetIpv6ReceivePacketInfoResponder)> {
        if let DatagramSocketRequest::SetIpv6ReceivePacketInfo { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_receive_packet_info(
        self,
    ) -> Option<(DatagramSocketGetIpv6ReceivePacketInfoResponder)> {
        if let DatagramSocketRequest::GetIpv6ReceivePacketInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_original_destination(
        self,
    ) -> Option<(DatagramSocketGetOriginalDestinationResponder)> {
        if let DatagramSocketRequest::GetOriginalDestination { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_info(self) -> Option<(DatagramSocketGetInfoResponder)> {
        if let DatagramSocketRequest::GetInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_describe(self) -> Option<(DatagramSocketDescribeResponder)> {
        if let DatagramSocketRequest::Describe { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_send_msg_preflight(
        self,
    ) -> Option<(DatagramSocketSendMsgPreflightRequest, DatagramSocketSendMsgPreflightResponder)>
    {
        if let DatagramSocketRequest::SendMsgPreflight { payload, responder } = self {
            Some((payload, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_recv_msg_postflight(self) -> Option<(DatagramSocketRecvMsgPostflightResponder)> {
        if let DatagramSocketRequest::RecvMsgPostflight { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DatagramSocketRequest::Clone { .. } => "clone",
            DatagramSocketRequest::Close { .. } => "close",
            DatagramSocketRequest::Query { .. } => "query",
            DatagramSocketRequest::SetReuseAddress { .. } => "set_reuse_address",
            DatagramSocketRequest::GetReuseAddress { .. } => "get_reuse_address",
            DatagramSocketRequest::GetError { .. } => "get_error",
            DatagramSocketRequest::SetBroadcast { .. } => "set_broadcast",
            DatagramSocketRequest::GetBroadcast { .. } => "get_broadcast",
            DatagramSocketRequest::SetSendBuffer { .. } => "set_send_buffer",
            DatagramSocketRequest::GetSendBuffer { .. } => "get_send_buffer",
            DatagramSocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
            DatagramSocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
            DatagramSocketRequest::SetKeepAlive { .. } => "set_keep_alive",
            DatagramSocketRequest::GetKeepAlive { .. } => "get_keep_alive",
            DatagramSocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
            DatagramSocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
            DatagramSocketRequest::SetNoCheck { .. } => "set_no_check",
            DatagramSocketRequest::GetNoCheck { .. } => "get_no_check",
            DatagramSocketRequest::SetLinger { .. } => "set_linger",
            DatagramSocketRequest::GetLinger { .. } => "get_linger",
            DatagramSocketRequest::SetReusePort { .. } => "set_reuse_port",
            DatagramSocketRequest::GetReusePort { .. } => "get_reuse_port",
            DatagramSocketRequest::GetAcceptConn { .. } => "get_accept_conn",
            DatagramSocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
            DatagramSocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
            DatagramSocketRequest::SetBindToInterfaceIndex { .. } => "set_bind_to_interface_index",
            DatagramSocketRequest::GetBindToInterfaceIndex { .. } => "get_bind_to_interface_index",
            DatagramSocketRequest::SetTimestamp { .. } => "set_timestamp",
            DatagramSocketRequest::GetTimestamp { .. } => "get_timestamp",
            DatagramSocketRequest::SetMark { .. } => "set_mark",
            DatagramSocketRequest::GetMark { .. } => "get_mark",
            DatagramSocketRequest::GetCookie { .. } => "get_cookie",
            DatagramSocketRequest::Bind { .. } => "bind",
            DatagramSocketRequest::Connect { .. } => "connect",
            DatagramSocketRequest::Disconnect { .. } => "disconnect",
            DatagramSocketRequest::GetSockName { .. } => "get_sock_name",
            DatagramSocketRequest::GetPeerName { .. } => "get_peer_name",
            DatagramSocketRequest::Shutdown { .. } => "shutdown",
            DatagramSocketRequest::SetIpTypeOfService { .. } => "set_ip_type_of_service",
            DatagramSocketRequest::GetIpTypeOfService { .. } => "get_ip_type_of_service",
            DatagramSocketRequest::SetIpTtl { .. } => "set_ip_ttl",
            DatagramSocketRequest::GetIpTtl { .. } => "get_ip_ttl",
            DatagramSocketRequest::SetIpPacketInfo { .. } => "set_ip_packet_info",
            DatagramSocketRequest::GetIpPacketInfo { .. } => "get_ip_packet_info",
            DatagramSocketRequest::SetIpReceiveTypeOfService { .. } => {
                "set_ip_receive_type_of_service"
            }
            DatagramSocketRequest::GetIpReceiveTypeOfService { .. } => {
                "get_ip_receive_type_of_service"
            }
            DatagramSocketRequest::SetIpReceiveTtl { .. } => "set_ip_receive_ttl",
            DatagramSocketRequest::GetIpReceiveTtl { .. } => "get_ip_receive_ttl",
            DatagramSocketRequest::SetIpMulticastInterface { .. } => "set_ip_multicast_interface",
            DatagramSocketRequest::GetIpMulticastInterface { .. } => "get_ip_multicast_interface",
            DatagramSocketRequest::SetIpMulticastTtl { .. } => "set_ip_multicast_ttl",
            DatagramSocketRequest::GetIpMulticastTtl { .. } => "get_ip_multicast_ttl",
            DatagramSocketRequest::SetIpMulticastLoopback { .. } => "set_ip_multicast_loopback",
            DatagramSocketRequest::GetIpMulticastLoopback { .. } => "get_ip_multicast_loopback",
            DatagramSocketRequest::AddIpMembership { .. } => "add_ip_membership",
            DatagramSocketRequest::DropIpMembership { .. } => "drop_ip_membership",
            DatagramSocketRequest::SetIpTransparent { .. } => "set_ip_transparent",
            DatagramSocketRequest::GetIpTransparent { .. } => "get_ip_transparent",
            DatagramSocketRequest::SetIpReceiveOriginalDestinationAddress { .. } => {
                "set_ip_receive_original_destination_address"
            }
            DatagramSocketRequest::GetIpReceiveOriginalDestinationAddress { .. } => {
                "get_ip_receive_original_destination_address"
            }
            DatagramSocketRequest::AddIpv6Membership { .. } => "add_ipv6_membership",
            DatagramSocketRequest::DropIpv6Membership { .. } => "drop_ipv6_membership",
            DatagramSocketRequest::SetIpv6MulticastInterface { .. } => {
                "set_ipv6_multicast_interface"
            }
            DatagramSocketRequest::GetIpv6MulticastInterface { .. } => {
                "get_ipv6_multicast_interface"
            }
            DatagramSocketRequest::SetIpv6UnicastHops { .. } => "set_ipv6_unicast_hops",
            DatagramSocketRequest::GetIpv6UnicastHops { .. } => "get_ipv6_unicast_hops",
            DatagramSocketRequest::SetIpv6ReceiveHopLimit { .. } => "set_ipv6_receive_hop_limit",
            DatagramSocketRequest::GetIpv6ReceiveHopLimit { .. } => "get_ipv6_receive_hop_limit",
            DatagramSocketRequest::SetIpv6MulticastHops { .. } => "set_ipv6_multicast_hops",
            DatagramSocketRequest::GetIpv6MulticastHops { .. } => "get_ipv6_multicast_hops",
            DatagramSocketRequest::SetIpv6MulticastLoopback { .. } => "set_ipv6_multicast_loopback",
            DatagramSocketRequest::GetIpv6MulticastLoopback { .. } => "get_ipv6_multicast_loopback",
            DatagramSocketRequest::SetIpv6Only { .. } => "set_ipv6_only",
            DatagramSocketRequest::GetIpv6Only { .. } => "get_ipv6_only",
            DatagramSocketRequest::SetIpv6ReceiveTrafficClass { .. } => {
                "set_ipv6_receive_traffic_class"
            }
            DatagramSocketRequest::GetIpv6ReceiveTrafficClass { .. } => {
                "get_ipv6_receive_traffic_class"
            }
            DatagramSocketRequest::SetIpv6TrafficClass { .. } => "set_ipv6_traffic_class",
            DatagramSocketRequest::GetIpv6TrafficClass { .. } => "get_ipv6_traffic_class",
            DatagramSocketRequest::SetIpv6ReceivePacketInfo { .. } => {
                "set_ipv6_receive_packet_info"
            }
            DatagramSocketRequest::GetIpv6ReceivePacketInfo { .. } => {
                "get_ipv6_receive_packet_info"
            }
            DatagramSocketRequest::GetOriginalDestination { .. } => "get_original_destination",
            DatagramSocketRequest::GetInfo { .. } => "get_info",
            DatagramSocketRequest::Describe { .. } => "describe",
            DatagramSocketRequest::SendMsgPreflight { .. } => "send_msg_preflight",
            DatagramSocketRequest::RecvMsgPostflight { .. } => "recv_msg_postflight",
        }
    }
}

#[derive(Debug, Clone)]
pub struct DatagramSocketControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for DatagramSocketControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl DatagramSocketControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketCloseResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketCloseResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketCloseResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketCloseResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
                result,
                self.tx_id,
                0x5ac5d459ad7f657e,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketQueryResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketQueryResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketQueryResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketQueryResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(protocol);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(protocol);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
            (protocol,),
            self.tx_id,
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetReuseAddressResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetReuseAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetReuseAddressResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetReuseAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x1fd74ee8b9a4a876,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetReuseAddressResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetReuseAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetReuseAddressResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetReuseAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetReuseAddressResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x67b7206b8d1bc0a5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetErrorResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetErrorResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetErrorResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetErrorResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x5aad39b33e5f6ebb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetBroadcastResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetBroadcastResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetBroadcastResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetBroadcastResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6023e081ce3cd947,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetBroadcastResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetBroadcastResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetBroadcastResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetBroadcastResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetBroadcastResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x68796fc556f9780d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetSendBufferResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetSendBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetSendBufferResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetSendBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x756eac32d73a7a70,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetSendBufferResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetSendBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetSendBufferResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetSendBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetSendBufferResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value_bytes| (value_bytes,)),
            self.tx_id,
            0x78a52fd9c7b2410b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetReceiveBufferResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetReceiveBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetReceiveBufferResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetReceiveBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6b0cf2f1919c7001,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetReceiveBufferResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetReceiveBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetReceiveBufferResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetReceiveBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetReceiveBufferResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value_bytes| (value_bytes,)),
            self.tx_id,
            0x14c1a4b64f709e5c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetKeepAliveResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetKeepAliveResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetKeepAliveResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetKeepAliveResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x572df8f0b920d2c7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetKeepAliveResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetKeepAliveResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetKeepAliveResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetKeepAliveResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetKeepAliveResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2dd29d3215f2c9d2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetOutOfBandInlineResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetOutOfBandInlineResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetOutOfBandInlineResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetOutOfBandInlineResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x3ecb49968bee439,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetOutOfBandInlineResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetOutOfBandInlineResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetOutOfBandInlineResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetOutOfBandInlineResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetOutOfBandInlineResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x348c1ab3aeca1745,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetNoCheckResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetNoCheckResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetNoCheckResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetNoCheckResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6bbf00c53a4c78c2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetNoCheckResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetNoCheckResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetNoCheckResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetNoCheckResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetNoCheckResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2cd4249286417694,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetLingerResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetLingerResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetLingerResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetLingerResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x45386351246e998e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetLingerResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetLingerResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetLingerResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetLingerResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetLingerResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x48eb20fc5ccb0e45,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetReusePortResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetReusePortResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetReusePortResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetReusePortResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x24dd3e5cb36d9ccb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetReusePortResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetReusePortResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetReusePortResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetReusePortResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetReusePortResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x7a112c1ab54ff828,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetAcceptConnResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetAcceptConnResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetAcceptConnResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetAcceptConnResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetAcceptConnResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x67ce6db6c2ec8966,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetBindToDeviceResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetBindToDeviceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetBindToDeviceResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetBindToDeviceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x2118b483f28aafc4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetBindToDeviceResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetBindToDeviceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetBindToDeviceResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetBindToDeviceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetBindToDeviceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x1ab1fbf0ef7906c8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetBindToInterfaceIndexResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetBindToInterfaceIndexResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetBindToInterfaceIndexResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetBindToInterfaceIndexResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6e387a0def00821,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetBindToInterfaceIndexResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetBindToInterfaceIndexResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetBindToInterfaceIndexResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetBindToInterfaceIndexResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetBindToInterfaceIndexResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x59c31dd3e3078295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetTimestampResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetTimestampResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetTimestampResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetTimestampResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x285d6516c263d839,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetTimestampResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetTimestampResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetTimestampResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetTimestampResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetTimestampResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x49f2fffbbcc2bd27,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetMarkResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetMarkResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetMarkResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetMarkResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6ead6de09f653236,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetMarkResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetMarkResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetMarkResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetMarkResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetMarkResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|mark| (mark,)),
            self.tx_id,
            0x57a2752c61d93d47,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetCookieResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetCookieResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetCookieResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetCookieResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetCookieResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2c2f47fd8f924e52,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketBindResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketBindResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketBindResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketBindResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x4bc6400ae92125d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketConnectResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketConnectResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketConnectResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketConnectResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x5f05f19bfdd38871,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketDisconnectResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketDisconnectResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketDisconnectResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketDisconnectResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x74e63b91f7b29b2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetSockNameResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetSockNameResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetSockNameResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetSockNameResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetSockNameResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|addr| (addr,)),
            self.tx_id,
            0x475f23f84a1a4f85,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetPeerNameResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetPeerNameResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetPeerNameResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetPeerNameResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetPeerNameResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|addr| (addr,)),
            self.tx_id,
            0x1ffecf4bd5b6432e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketShutdownResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketShutdownResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketShutdownResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketShutdownResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x247f38b6db68c336,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpTypeOfServiceResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x995c600475b6d46,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpTypeOfServiceResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpTypeOfServiceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x3814a04259f75fcb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpTtlResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpTtlResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x29e2424b433ae1ef,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpTtlResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpTtlResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpTtlResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x47e47fa1f24da471,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpPacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpPacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpPacketInfoResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpPacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x392d16bee20c0e16,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpPacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpPacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpPacketInfoResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpPacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpPacketInfoResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x54b505f242280740,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpReceiveTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpReceiveTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpReceiveTypeOfServiceResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpReceiveTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6c4f6714995f84ef,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpReceiveTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpReceiveTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpReceiveTypeOfServiceResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpReceiveTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4158ba7dc2795960,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpReceiveTtlResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpReceiveTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpReceiveTtlResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpReceiveTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x46f15be0ce0ab82b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpReceiveTtlResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpReceiveTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpReceiveTtlResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpReceiveTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpReceiveTtlResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x678ddd5a5dfa2eb5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpMulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpMulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpMulticastInterfaceResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpMulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x752fbfa9b12befe,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpMulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpMulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpMulticastInterfaceResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpMulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpMulticastInterfaceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x320bd14c4df046c4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpMulticastTtlResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpMulticastTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpMulticastTtlResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpMulticastTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x63134d53772916a1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpMulticastTtlResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpMulticastTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpMulticastTtlResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpMulticastTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpMulticastTtlResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4665cd378f39e1a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpMulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpMulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpMulticastLoopbackResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpMulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x20c55c11f00943ea,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpMulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpMulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpMulticastLoopbackResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpMulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpMulticastLoopbackResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x3b6b26ff558298f2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketAddIpMembershipResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketAddIpMembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketAddIpMembershipResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketAddIpMembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x76bc7df115a3b4d0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketDropIpMembershipResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketDropIpMembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketDropIpMembershipResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketDropIpMembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x2888f3099188d03,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpTransparentResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpTransparentResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpTransparentResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpTransparentResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x1ae532b0c066e3a0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpTransparentResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpTransparentResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpTransparentResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpTransparentResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpTransparentResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x51d43695962ebfb5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x4722b4ce52f7840,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2a0e7dc5d6bfdfe9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketAddIpv6MembershipResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketAddIpv6MembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketAddIpv6MembershipResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketAddIpv6MembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x7c94727acb4ea4b3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketDropIpv6MembershipResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketDropIpv6MembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketDropIpv6MembershipResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketDropIpv6MembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x42104c70ccaba304,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpv6MulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpv6MulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpv6MulticastInterfaceResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpv6MulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x135f76db3774ab3b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpv6MulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpv6MulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpv6MulticastInterfaceResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpv6MulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x1f26fcdd348f1882,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpv6UnicastHopsResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpv6UnicastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpv6UnicastHopsResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpv6UnicastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x157d51e98f462859,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpv6UnicastHopsResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpv6UnicastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpv6UnicastHopsResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpv6UnicastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6UnicastHopsResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x21f4641cad8bd8d2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpv6ReceiveHopLimitResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpv6ReceiveHopLimitResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpv6ReceiveHopLimitResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpv6ReceiveHopLimitResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x5c24808ed2e84a1e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpv6ReceiveHopLimitResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpv6ReceiveHopLimitResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpv6ReceiveHopLimitResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpv6ReceiveHopLimitResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x341e06689885b4c0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpv6MulticastHopsResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpv6MulticastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpv6MulticastHopsResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpv6MulticastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x25b9cd4d181f82c1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpv6MulticastHopsResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpv6MulticastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpv6MulticastHopsResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpv6MulticastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6MulticastHopsResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x52916948a365012a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpv6MulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpv6MulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpv6MulticastLoopbackResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpv6MulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x55701c409ff41b40,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpv6MulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpv6MulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpv6MulticastLoopbackResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpv6MulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4415b701fde319c3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpv6OnlyResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpv6OnlyResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpv6OnlyResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpv6OnlyResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x4873f1364758cbba,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpv6OnlyResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpv6OnlyResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpv6OnlyResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpv6OnlyResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6OnlyResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4aa3340a1a26b89c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpv6ReceiveTrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpv6ReceiveTrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpv6ReceiveTrafficClassResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpv6ReceiveTrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x58f07c8788d099a0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpv6ReceiveTrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpv6ReceiveTrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpv6ReceiveTrafficClassResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpv6ReceiveTrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2e334df1da553ffa,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpv6TrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpv6TrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpv6TrafficClassResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpv6TrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6af077800c5a0b4f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpv6TrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpv6TrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpv6TrafficClassResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpv6TrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6TrafficClassResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x6baf6eed8fc2f04,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSetIpv6ReceivePacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSetIpv6ReceivePacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSetIpv6ReceivePacketInfoResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSetIpv6ReceivePacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x19259775b1a92768,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetIpv6ReceivePacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetIpv6ReceivePacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetIpv6ReceivePacketInfoResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetIpv6ReceivePacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x7acd4a2775baec75,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetOriginalDestinationResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetOriginalDestinationResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetOriginalDestinationResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetOriginalDestinationResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetOriginalDestinationResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x38bf28f0dafdbac0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketGetInfoResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketGetInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketGetInfoResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketGetInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseDatagramSocketGetInfoResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x48aa0a1f6a32d2ed,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketDescribeResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketDescribeResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketDescribeResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketDescribeResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut payload: DatagramSocketDescribeResponse) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut payload: DatagramSocketDescribeResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut payload: DatagramSocketDescribeResponse) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<DatagramSocketDescribeResponse>(
            &mut payload,
            self.tx_id,
            0xbf1e2f0a86601f3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketSendMsgPreflightResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketSendMsgPreflightResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketSendMsgPreflightResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketSendMsgPreflightResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<DatagramSocketSendMsgPreflightResponse, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<DatagramSocketSendMsgPreflightResponse, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<DatagramSocketSendMsgPreflightResponse, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            DatagramSocketSendMsgPreflightResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.as_mut().map_err(|e| *e),
            self.tx_id,
            0x5362e668e777248a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DatagramSocketRecvMsgPostflightResponder {
    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DatagramSocketRecvMsgPostflightResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DatagramSocketRecvMsgPostflightResponder {
    type ControlHandle = DatagramSocketControlHandle;

    fn control_handle(&self) -> &DatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DatagramSocketRecvMsgPostflightResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<DatagramSocketRecvMsgPostflightResponse, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<DatagramSocketRecvMsgPostflightResponse, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<DatagramSocketRecvMsgPostflightResponse, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            DatagramSocketRecvMsgPostflightResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.as_mut().map_err(|e| *e),
            self.tx_id,
            0x1a7cdeca5f3eb8e2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ProviderMarker;

impl fidl::endpoints::ProtocolMarker for ProviderMarker {
    type Proxy = ProviderProxy;
    type RequestStream = ProviderRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ProviderSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.posix.socket.Provider";
}
impl fidl::endpoints::DiscoverableProtocolMarker for ProviderMarker {}
pub type ProviderStreamSocketWithOptionsResult =
    Result<fidl::endpoints::ClientEnd<StreamSocketMarker>, fidl_fuchsia_posix::Errno>;
pub type ProviderStreamSocketResult =
    Result<fidl::endpoints::ClientEnd<StreamSocketMarker>, fidl_fuchsia_posix::Errno>;
pub type ProviderDatagramSocketDeprecatedResult =
    Result<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>, fidl_fuchsia_posix::Errno>;
pub type ProviderDatagramSocketResult =
    Result<ProviderDatagramSocketResponse, fidl_fuchsia_posix::Errno>;
pub type ProviderDatagramSocketWithOptionsResult =
    Result<ProviderDatagramSocketWithOptionsResponse, fidl_fuchsia_posix::Errno>;
pub type ProviderInterfaceIndexToNameResult = Result<String, i32>;
pub type ProviderInterfaceNameToIndexResult = Result<u64, i32>;
pub type ProviderInterfaceNameToFlagsResult = Result<InterfaceFlags, i32>;

pub trait ProviderProxyInterface: Send + Sync {
    type StreamSocketWithOptionsResponseFut: std::future::Future<Output = Result<ProviderStreamSocketWithOptionsResult, fidl::Error>>
        + Send;
    fn r#stream_socket_with_options(
        &self,
        domain: Domain,
        proto: StreamSocketProtocol,
        opts: SocketCreationOptions,
    ) -> Self::StreamSocketWithOptionsResponseFut;
    type StreamSocketResponseFut: std::future::Future<Output = Result<ProviderStreamSocketResult, fidl::Error>>
        + Send;
    fn r#stream_socket(
        &self,
        domain: Domain,
        proto: StreamSocketProtocol,
    ) -> Self::StreamSocketResponseFut;
    type DatagramSocketDeprecatedResponseFut: std::future::Future<Output = Result<ProviderDatagramSocketDeprecatedResult, fidl::Error>>
        + Send;
    fn r#datagram_socket_deprecated(
        &self,
        domain: Domain,
        proto: DatagramSocketProtocol,
    ) -> Self::DatagramSocketDeprecatedResponseFut;
    type DatagramSocketResponseFut: std::future::Future<Output = Result<ProviderDatagramSocketResult, fidl::Error>>
        + Send;
    fn r#datagram_socket(
        &self,
        domain: Domain,
        proto: DatagramSocketProtocol,
    ) -> Self::DatagramSocketResponseFut;
    type DatagramSocketWithOptionsResponseFut: std::future::Future<Output = Result<ProviderDatagramSocketWithOptionsResult, fidl::Error>>
        + Send;
    fn r#datagram_socket_with_options(
        &self,
        domain: Domain,
        proto: DatagramSocketProtocol,
        opts: SocketCreationOptions,
    ) -> Self::DatagramSocketWithOptionsResponseFut;
    type InterfaceIndexToNameResponseFut: std::future::Future<Output = Result<ProviderInterfaceIndexToNameResult, fidl::Error>>
        + Send;
    fn r#interface_index_to_name(&self, index: u64) -> Self::InterfaceIndexToNameResponseFut;
    type InterfaceNameToIndexResponseFut: std::future::Future<Output = Result<ProviderInterfaceNameToIndexResult, fidl::Error>>
        + Send;
    fn r#interface_name_to_index(&self, name: &str) -> Self::InterfaceNameToIndexResponseFut;
    type InterfaceNameToFlagsResponseFut: std::future::Future<Output = Result<ProviderInterfaceNameToFlagsResult, fidl::Error>>
        + Send;
    fn r#interface_name_to_flags(&self, name: &str) -> Self::InterfaceNameToFlagsResponseFut;
    type GetInterfaceAddressesResponseFut: std::future::Future<Output = Result<Vec<InterfaceAddresses>, fidl::Error>>
        + Send;
    fn r#get_interface_addresses(&self) -> Self::GetInterfaceAddressesResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ProviderSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ProviderSynchronousProxy {
    type Proxy = ProviderProxy;
    type Protocol = ProviderMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl ProviderSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<ProviderEvent, fidl::Error> {
        ProviderEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Requests a stream socket with the specified parameters and the creation
    /// options.
    pub fn r#stream_socket_with_options(
        &self,
        mut domain: Domain,
        mut proto: StreamSocketProtocol,
        mut opts: SocketCreationOptions,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProviderStreamSocketWithOptionsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<ProviderStreamSocketWithOptionsRequest, fidl::encoding::ResultType<
                ProviderStreamSocketWithOptionsResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (domain, proto, &mut opts),
                0x3969bf7eb78386e0,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.s))
    }

    /// Requests a stream socket with the specified parameters.
    pub fn r#stream_socket(
        &self,
        mut domain: Domain,
        mut proto: StreamSocketProtocol,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProviderStreamSocketResult, fidl::Error> {
        let _response =
            self.client.send_query::<ProviderStreamSocketRequest, fidl::encoding::ResultType<
                ProviderStreamSocketResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (domain, proto),
                0x27c3581da2155545,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.s))
    }

    /// Requests a datagram socket with the specified parameters.
    /// TODO(https://fxbug.dev/42165881): Remove this method once no more callers rely on it.
    pub fn r#datagram_socket_deprecated(
        &self,
        mut domain: Domain,
        mut proto: DatagramSocketProtocol,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProviderDatagramSocketDeprecatedResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<ProviderDatagramSocketDeprecatedRequest, fidl::encoding::ResultType<
                ProviderDatagramSocketDeprecatedResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (domain, proto),
                0x38876c87cf031cb1,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.s))
    }

    /// Requests a datagram socket with the specified parameters.
    pub fn r#datagram_socket(
        &self,
        mut domain: Domain,
        mut proto: DatagramSocketProtocol,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProviderDatagramSocketResult, fidl::Error> {
        let _response =
            self.client.send_query::<ProviderDatagramSocketRequest, fidl::encoding::ResultType<
                ProviderDatagramSocketResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (domain, proto),
                0x4021b4fa1b6452f2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Requests a datagram socket with the specified parameters and the creation
    /// options.
    pub fn r#datagram_socket_with_options(
        &self,
        mut domain: Domain,
        mut proto: DatagramSocketProtocol,
        mut opts: SocketCreationOptions,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProviderDatagramSocketWithOptionsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<ProviderDatagramSocketWithOptionsRequest, fidl::encoding::ResultType<
                ProviderDatagramSocketWithOptionsResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (domain, proto, &mut opts),
                0x4cd0cffbffa39eb1,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Looks up an interface by its index and returns its name. Returns
    /// `ZX_ERR_NOT_FOUND` if the specified index doesn't exist.
    pub fn r#interface_index_to_name(
        &self,
        mut index: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProviderInterfaceIndexToNameResult, fidl::Error> {
        let _response = self.client.send_query::<
            ProviderInterfaceIndexToNameRequest,
            fidl::encoding::ResultType<ProviderInterfaceIndexToNameResponse, i32>,
        >(
            (index,),
            0x4d59a64fce98272f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.name))
    }

    /// Looks up an interface by its name and returns its index. Returns
    /// `ZX_ERR_NOT_FOUND` if the specified name doesn't exist.
    pub fn r#interface_name_to_index(
        &self,
        mut name: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProviderInterfaceNameToIndexResult, fidl::Error> {
        let _response = self.client.send_query::<
            ProviderInterfaceNameToIndexRequest,
            fidl::encoding::ResultType<ProviderInterfaceNameToIndexResponse, i32>,
        >(
            (name,),
            0x690cd8d2f2d650f8,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.index))
    }

    /// Looks up an interface by its name and returns its flags. Returns
    /// `ZX_ERR_NOT_FOUND` if the specified name doesn't exist.
    pub fn r#interface_name_to_flags(
        &self,
        mut name: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ProviderInterfaceNameToFlagsResult, fidl::Error> {
        let _response = self.client.send_query::<
            ProviderInterfaceNameToFlagsRequest,
            fidl::encoding::ResultType<ProviderInterfaceNameToFlagsResponse, i32>,
        >(
            (name,),
            0x25d0efcdb6671a0b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.flags))
    }

    /// Requests a list of [`fuchsia.posix.socket.InterfaceAddresses`]
    /// describing the network interfaces on the system.
    pub fn r#get_interface_addresses(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<InterfaceAddresses>, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, ProviderGetInterfaceAddressesResponse>(
                (),
                0x2e7b9aaf327c870,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.interfaces)
    }
}

#[cfg(target_os = "fuchsia")]
impl From<ProviderSynchronousProxy> for zx::Handle {
    fn from(value: ProviderSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for ProviderSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for ProviderSynchronousProxy {
    type Protocol = ProviderMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<ProviderMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct ProviderProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for ProviderProxy {
    type Protocol = ProviderMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl ProviderProxy {
    /// Create a new Proxy for fuchsia.posix.socket/Provider.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> ProviderEventStream {
        ProviderEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Requests a stream socket with the specified parameters and the creation
    /// options.
    pub fn r#stream_socket_with_options(
        &self,
        mut domain: Domain,
        mut proto: StreamSocketProtocol,
        mut opts: SocketCreationOptions,
    ) -> fidl::client::QueryResponseFut<
        ProviderStreamSocketWithOptionsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ProviderProxyInterface::r#stream_socket_with_options(self, domain, proto, opts)
    }

    /// Requests a stream socket with the specified parameters.
    pub fn r#stream_socket(
        &self,
        mut domain: Domain,
        mut proto: StreamSocketProtocol,
    ) -> fidl::client::QueryResponseFut<
        ProviderStreamSocketResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ProviderProxyInterface::r#stream_socket(self, domain, proto)
    }

    /// Requests a datagram socket with the specified parameters.
    /// TODO(https://fxbug.dev/42165881): Remove this method once no more callers rely on it.
    pub fn r#datagram_socket_deprecated(
        &self,
        mut domain: Domain,
        mut proto: DatagramSocketProtocol,
    ) -> fidl::client::QueryResponseFut<
        ProviderDatagramSocketDeprecatedResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ProviderProxyInterface::r#datagram_socket_deprecated(self, domain, proto)
    }

    /// Requests a datagram socket with the specified parameters.
    pub fn r#datagram_socket(
        &self,
        mut domain: Domain,
        mut proto: DatagramSocketProtocol,
    ) -> fidl::client::QueryResponseFut<
        ProviderDatagramSocketResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ProviderProxyInterface::r#datagram_socket(self, domain, proto)
    }

    /// Requests a datagram socket with the specified parameters and the creation
    /// options.
    pub fn r#datagram_socket_with_options(
        &self,
        mut domain: Domain,
        mut proto: DatagramSocketProtocol,
        mut opts: SocketCreationOptions,
    ) -> fidl::client::QueryResponseFut<
        ProviderDatagramSocketWithOptionsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ProviderProxyInterface::r#datagram_socket_with_options(self, domain, proto, opts)
    }

    /// Looks up an interface by its index and returns its name. Returns
    /// `ZX_ERR_NOT_FOUND` if the specified index doesn't exist.
    pub fn r#interface_index_to_name(
        &self,
        mut index: u64,
    ) -> fidl::client::QueryResponseFut<
        ProviderInterfaceIndexToNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ProviderProxyInterface::r#interface_index_to_name(self, index)
    }

    /// Looks up an interface by its name and returns its index. Returns
    /// `ZX_ERR_NOT_FOUND` if the specified name doesn't exist.
    pub fn r#interface_name_to_index(
        &self,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<
        ProviderInterfaceNameToIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ProviderProxyInterface::r#interface_name_to_index(self, name)
    }

    /// Looks up an interface by its name and returns its flags. Returns
    /// `ZX_ERR_NOT_FOUND` if the specified name doesn't exist.
    pub fn r#interface_name_to_flags(
        &self,
        mut name: &str,
    ) -> fidl::client::QueryResponseFut<
        ProviderInterfaceNameToFlagsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ProviderProxyInterface::r#interface_name_to_flags(self, name)
    }

    /// Requests a list of [`fuchsia.posix.socket.InterfaceAddresses`]
    /// describing the network interfaces on the system.
    pub fn r#get_interface_addresses(
        &self,
    ) -> fidl::client::QueryResponseFut<
        Vec<InterfaceAddresses>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ProviderProxyInterface::r#get_interface_addresses(self)
    }
}

impl ProviderProxyInterface for ProviderProxy {
    type StreamSocketWithOptionsResponseFut = fidl::client::QueryResponseFut<
        ProviderStreamSocketWithOptionsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#stream_socket_with_options(
        &self,
        mut domain: Domain,
        mut proto: StreamSocketProtocol,
        mut opts: SocketCreationOptions,
    ) -> Self::StreamSocketWithOptionsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProviderStreamSocketWithOptionsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    ProviderStreamSocketWithOptionsResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3969bf7eb78386e0,
            >(_buf?)?;
            Ok(_response.map(|x| x.s))
        }
        self.client.send_query_and_decode::<
            ProviderStreamSocketWithOptionsRequest,
            ProviderStreamSocketWithOptionsResult,
        >(
            (domain, proto, &mut opts,),
            0x3969bf7eb78386e0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type StreamSocketResponseFut = fidl::client::QueryResponseFut<
        ProviderStreamSocketResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#stream_socket(
        &self,
        mut domain: Domain,
        mut proto: StreamSocketProtocol,
    ) -> Self::StreamSocketResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProviderStreamSocketResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ProviderStreamSocketResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x27c3581da2155545,
            >(_buf?)?;
            Ok(_response.map(|x| x.s))
        }
        self.client
            .send_query_and_decode::<ProviderStreamSocketRequest, ProviderStreamSocketResult>(
                (domain, proto),
                0x27c3581da2155545,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type DatagramSocketDeprecatedResponseFut = fidl::client::QueryResponseFut<
        ProviderDatagramSocketDeprecatedResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#datagram_socket_deprecated(
        &self,
        mut domain: Domain,
        mut proto: DatagramSocketProtocol,
    ) -> Self::DatagramSocketDeprecatedResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProviderDatagramSocketDeprecatedResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    ProviderDatagramSocketDeprecatedResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x38876c87cf031cb1,
            >(_buf?)?;
            Ok(_response.map(|x| x.s))
        }
        self.client.send_query_and_decode::<
            ProviderDatagramSocketDeprecatedRequest,
            ProviderDatagramSocketDeprecatedResult,
        >(
            (domain, proto,),
            0x38876c87cf031cb1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DatagramSocketResponseFut = fidl::client::QueryResponseFut<
        ProviderDatagramSocketResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#datagram_socket(
        &self,
        mut domain: Domain,
        mut proto: DatagramSocketProtocol,
    ) -> Self::DatagramSocketResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProviderDatagramSocketResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    ProviderDatagramSocketResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4021b4fa1b6452f2,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<ProviderDatagramSocketRequest, ProviderDatagramSocketResult>(
                (domain, proto),
                0x4021b4fa1b6452f2,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type DatagramSocketWithOptionsResponseFut = fidl::client::QueryResponseFut<
        ProviderDatagramSocketWithOptionsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#datagram_socket_with_options(
        &self,
        mut domain: Domain,
        mut proto: DatagramSocketProtocol,
        mut opts: SocketCreationOptions,
    ) -> Self::DatagramSocketWithOptionsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProviderDatagramSocketWithOptionsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    ProviderDatagramSocketWithOptionsResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4cd0cffbffa39eb1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            ProviderDatagramSocketWithOptionsRequest,
            ProviderDatagramSocketWithOptionsResult,
        >(
            (domain, proto, &mut opts,),
            0x4cd0cffbffa39eb1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type InterfaceIndexToNameResponseFut = fidl::client::QueryResponseFut<
        ProviderInterfaceIndexToNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#interface_index_to_name(&self, mut index: u64) -> Self::InterfaceIndexToNameResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProviderInterfaceIndexToNameResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ProviderInterfaceIndexToNameResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4d59a64fce98272f,
            >(_buf?)?;
            Ok(_response.map(|x| x.name))
        }
        self.client.send_query_and_decode::<
            ProviderInterfaceIndexToNameRequest,
            ProviderInterfaceIndexToNameResult,
        >(
            (index,),
            0x4d59a64fce98272f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type InterfaceNameToIndexResponseFut = fidl::client::QueryResponseFut<
        ProviderInterfaceNameToIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#interface_name_to_index(&self, mut name: &str) -> Self::InterfaceNameToIndexResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProviderInterfaceNameToIndexResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ProviderInterfaceNameToIndexResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x690cd8d2f2d650f8,
            >(_buf?)?;
            Ok(_response.map(|x| x.index))
        }
        self.client.send_query_and_decode::<
            ProviderInterfaceNameToIndexRequest,
            ProviderInterfaceNameToIndexResult,
        >(
            (name,),
            0x690cd8d2f2d650f8,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type InterfaceNameToFlagsResponseFut = fidl::client::QueryResponseFut<
        ProviderInterfaceNameToFlagsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#interface_name_to_flags(&self, mut name: &str) -> Self::InterfaceNameToFlagsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ProviderInterfaceNameToFlagsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ProviderInterfaceNameToFlagsResponse, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x25d0efcdb6671a0b,
            >(_buf?)?;
            Ok(_response.map(|x| x.flags))
        }
        self.client.send_query_and_decode::<
            ProviderInterfaceNameToFlagsRequest,
            ProviderInterfaceNameToFlagsResult,
        >(
            (name,),
            0x25d0efcdb6671a0b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetInterfaceAddressesResponseFut = fidl::client::QueryResponseFut<
        Vec<InterfaceAddresses>,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_interface_addresses(&self) -> Self::GetInterfaceAddressesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<InterfaceAddresses>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                ProviderGetInterfaceAddressesResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2e7b9aaf327c870,
            >(_buf?)?;
            Ok(_response.interfaces)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<InterfaceAddresses>>(
            (),
            0x2e7b9aaf327c870,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct ProviderEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for ProviderEventStream {}

impl futures::stream::FusedStream for ProviderEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for ProviderEventStream {
    type Item = Result<ProviderEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(ProviderEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum ProviderEvent {}

impl ProviderEvent {
    /// Decodes a message buffer as a [`ProviderEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ProviderEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.posix.socket/Provider.
pub struct ProviderRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for ProviderRequestStream {}

impl futures::stream::FusedStream for ProviderRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for ProviderRequestStream {
    type Protocol = ProviderMarker;
    type ControlHandle = ProviderControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        ProviderControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for ProviderRequestStream {
    type Item = Result<ProviderRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled ProviderRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x3969bf7eb78386e0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProviderStreamSocketWithOptionsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderStreamSocketWithOptionsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
                        Ok(ProviderRequest::StreamSocketWithOptions {
                            domain: req.domain,
                            proto: req.proto,
                            opts: req.opts,

                            responder: ProviderStreamSocketWithOptionsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x27c3581da2155545 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProviderStreamSocketRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderStreamSocketRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
                        Ok(ProviderRequest::StreamSocket {
                            domain: req.domain,
                            proto: req.proto,

                            responder: ProviderStreamSocketResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x38876c87cf031cb1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProviderDatagramSocketDeprecatedRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderDatagramSocketDeprecatedRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
                        Ok(ProviderRequest::DatagramSocketDeprecated {
                            domain: req.domain,
                            proto: req.proto,

                            responder: ProviderDatagramSocketDeprecatedResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4021b4fa1b6452f2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProviderDatagramSocketRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderDatagramSocketRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
                        Ok(ProviderRequest::DatagramSocket {
                            domain: req.domain,
                            proto: req.proto,

                            responder: ProviderDatagramSocketResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4cd0cffbffa39eb1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProviderDatagramSocketWithOptionsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderDatagramSocketWithOptionsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
                        Ok(ProviderRequest::DatagramSocketWithOptions {
                            domain: req.domain,
                            proto: req.proto,
                            opts: req.opts,

                            responder: ProviderDatagramSocketWithOptionsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4d59a64fce98272f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProviderInterfaceIndexToNameRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderInterfaceIndexToNameRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
                        Ok(ProviderRequest::InterfaceIndexToName {
                            index: req.index,

                            responder: ProviderInterfaceIndexToNameResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x690cd8d2f2d650f8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProviderInterfaceNameToIndexRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderInterfaceNameToIndexRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
                        Ok(ProviderRequest::InterfaceNameToIndex {
                            name: req.name,

                            responder: ProviderInterfaceNameToIndexResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x25d0efcdb6671a0b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            ProviderInterfaceNameToFlagsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderInterfaceNameToFlagsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
                        Ok(ProviderRequest::InterfaceNameToFlags {
                            name: req.name,

                            responder: ProviderInterfaceNameToFlagsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2e7b9aaf327c870 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
                        Ok(ProviderRequest::GetInterfaceAddresses {
                            responder: ProviderGetInterfaceAddressesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Provider implements the POSIX sockets API.
///
/// *Warning:* This protocol is not yet ready for direct use by clients.
/// Instead, clients should use the BSD sockets API to interact with sockets.
/// We plan to change this protocol substantially and clients that couple
/// directly to this protocol will make those changes more difficult.
#[derive(Debug)]
pub enum ProviderRequest {
    /// Requests a stream socket with the specified parameters and the creation
    /// options.
    StreamSocketWithOptions {
        domain: Domain,
        proto: StreamSocketProtocol,
        opts: SocketCreationOptions,
        responder: ProviderStreamSocketWithOptionsResponder,
    },
    /// Requests a stream socket with the specified parameters.
    StreamSocket {
        domain: Domain,
        proto: StreamSocketProtocol,
        responder: ProviderStreamSocketResponder,
    },
    /// Requests a datagram socket with the specified parameters.
    /// TODO(https://fxbug.dev/42165881): Remove this method once no more callers rely on it.
    DatagramSocketDeprecated {
        domain: Domain,
        proto: DatagramSocketProtocol,
        responder: ProviderDatagramSocketDeprecatedResponder,
    },
    /// Requests a datagram socket with the specified parameters.
    DatagramSocket {
        domain: Domain,
        proto: DatagramSocketProtocol,
        responder: ProviderDatagramSocketResponder,
    },
    /// Requests a datagram socket with the specified parameters and the creation
    /// options.
    DatagramSocketWithOptions {
        domain: Domain,
        proto: DatagramSocketProtocol,
        opts: SocketCreationOptions,
        responder: ProviderDatagramSocketWithOptionsResponder,
    },
    /// Looks up an interface by its index and returns its name. Returns
    /// `ZX_ERR_NOT_FOUND` if the specified index doesn't exist.
    InterfaceIndexToName { index: u64, responder: ProviderInterfaceIndexToNameResponder },
    /// Looks up an interface by its name and returns its index. Returns
    /// `ZX_ERR_NOT_FOUND` if the specified name doesn't exist.
    InterfaceNameToIndex { name: String, responder: ProviderInterfaceNameToIndexResponder },
    /// Looks up an interface by its name and returns its flags. Returns
    /// `ZX_ERR_NOT_FOUND` if the specified name doesn't exist.
    InterfaceNameToFlags { name: String, responder: ProviderInterfaceNameToFlagsResponder },
    /// Requests a list of [`fuchsia.posix.socket.InterfaceAddresses`]
    /// describing the network interfaces on the system.
    GetInterfaceAddresses { responder: ProviderGetInterfaceAddressesResponder },
}

impl ProviderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_stream_socket_with_options(
        self,
    ) -> Option<(
        Domain,
        StreamSocketProtocol,
        SocketCreationOptions,
        ProviderStreamSocketWithOptionsResponder,
    )> {
        if let ProviderRequest::StreamSocketWithOptions { domain, proto, opts, responder } = self {
            Some((domain, proto, opts, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stream_socket(
        self,
    ) -> Option<(Domain, StreamSocketProtocol, ProviderStreamSocketResponder)> {
        if let ProviderRequest::StreamSocket { domain, proto, responder } = self {
            Some((domain, proto, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_datagram_socket_deprecated(
        self,
    ) -> Option<(Domain, DatagramSocketProtocol, ProviderDatagramSocketDeprecatedResponder)> {
        if let ProviderRequest::DatagramSocketDeprecated { domain, proto, responder } = self {
            Some((domain, proto, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_datagram_socket(
        self,
    ) -> Option<(Domain, DatagramSocketProtocol, ProviderDatagramSocketResponder)> {
        if let ProviderRequest::DatagramSocket { domain, proto, responder } = self {
            Some((domain, proto, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_datagram_socket_with_options(
        self,
    ) -> Option<(
        Domain,
        DatagramSocketProtocol,
        SocketCreationOptions,
        ProviderDatagramSocketWithOptionsResponder,
    )> {
        if let ProviderRequest::DatagramSocketWithOptions { domain, proto, opts, responder } = self
        {
            Some((domain, proto, opts, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_interface_index_to_name(
        self,
    ) -> Option<(u64, ProviderInterfaceIndexToNameResponder)> {
        if let ProviderRequest::InterfaceIndexToName { index, responder } = self {
            Some((index, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_interface_name_to_index(
        self,
    ) -> Option<(String, ProviderInterfaceNameToIndexResponder)> {
        if let ProviderRequest::InterfaceNameToIndex { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_interface_name_to_flags(
        self,
    ) -> Option<(String, ProviderInterfaceNameToFlagsResponder)> {
        if let ProviderRequest::InterfaceNameToFlags { name, responder } = self {
            Some((name, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_interface_addresses(self) -> Option<(ProviderGetInterfaceAddressesResponder)> {
        if let ProviderRequest::GetInterfaceAddresses { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ProviderRequest::StreamSocketWithOptions { .. } => "stream_socket_with_options",
            ProviderRequest::StreamSocket { .. } => "stream_socket",
            ProviderRequest::DatagramSocketDeprecated { .. } => "datagram_socket_deprecated",
            ProviderRequest::DatagramSocket { .. } => "datagram_socket",
            ProviderRequest::DatagramSocketWithOptions { .. } => "datagram_socket_with_options",
            ProviderRequest::InterfaceIndexToName { .. } => "interface_index_to_name",
            ProviderRequest::InterfaceNameToIndex { .. } => "interface_name_to_index",
            ProviderRequest::InterfaceNameToFlags { .. } => "interface_name_to_flags",
            ProviderRequest::GetInterfaceAddresses { .. } => "get_interface_addresses",
        }
    }
}

#[derive(Debug, Clone)]
pub struct ProviderControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for ProviderControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl ProviderControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ProviderStreamSocketWithOptionsResponder {
    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for ProviderStreamSocketWithOptionsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ProviderStreamSocketWithOptionsResponder {
    type ControlHandle = ProviderControlHandle;

    fn control_handle(&self) -> &ProviderControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl ProviderStreamSocketWithOptionsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<
            fidl::endpoints::ClientEnd<StreamSocketMarker>,
            fidl_fuchsia_posix::Errno,
        >,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<
            fidl::endpoints::ClientEnd<StreamSocketMarker>,
            fidl_fuchsia_posix::Errno,
        >,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<
            fidl::endpoints::ClientEnd<StreamSocketMarker>,
            fidl_fuchsia_posix::Errno,
        >,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            ProviderStreamSocketWithOptionsResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|s| (s,)),
            self.tx_id,
            0x3969bf7eb78386e0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ProviderStreamSocketResponder {
    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for ProviderStreamSocketResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ProviderStreamSocketResponder {
    type ControlHandle = ProviderControlHandle;

    fn control_handle(&self) -> &ProviderControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl ProviderStreamSocketResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<
            fidl::endpoints::ClientEnd<StreamSocketMarker>,
            fidl_fuchsia_posix::Errno,
        >,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<
            fidl::endpoints::ClientEnd<StreamSocketMarker>,
            fidl_fuchsia_posix::Errno,
        >,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<
            fidl::endpoints::ClientEnd<StreamSocketMarker>,
            fidl_fuchsia_posix::Errno,
        >,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            ProviderStreamSocketResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|s| (s,)),
            self.tx_id,
            0x27c3581da2155545,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ProviderDatagramSocketDeprecatedResponder {
    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for ProviderDatagramSocketDeprecatedResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ProviderDatagramSocketDeprecatedResponder {
    type ControlHandle = ProviderControlHandle;

    fn control_handle(&self) -> &ProviderControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl ProviderDatagramSocketDeprecatedResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<
            fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
            fidl_fuchsia_posix::Errno,
        >,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<
            fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
            fidl_fuchsia_posix::Errno,
        >,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<
            fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
            fidl_fuchsia_posix::Errno,
        >,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            ProviderDatagramSocketDeprecatedResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|s| (s,)),
            self.tx_id,
            0x38876c87cf031cb1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ProviderDatagramSocketResponder {
    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for ProviderDatagramSocketResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ProviderDatagramSocketResponder {
    type ControlHandle = ProviderControlHandle;

    fn control_handle(&self) -> &ProviderControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl ProviderDatagramSocketResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<ProviderDatagramSocketResponse, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<ProviderDatagramSocketResponse, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<ProviderDatagramSocketResponse, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            ProviderDatagramSocketResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.as_mut().map_err(|e| *e),
            self.tx_id,
            0x4021b4fa1b6452f2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ProviderDatagramSocketWithOptionsResponder {
    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for ProviderDatagramSocketWithOptionsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ProviderDatagramSocketWithOptionsResponder {
    type ControlHandle = ProviderControlHandle;

    fn control_handle(&self) -> &ProviderControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl ProviderDatagramSocketWithOptionsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<ProviderDatagramSocketWithOptionsResponse, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<ProviderDatagramSocketWithOptionsResponse, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<ProviderDatagramSocketWithOptionsResponse, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            ProviderDatagramSocketWithOptionsResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.as_mut().map_err(|e| *e),
            self.tx_id,
            0x4cd0cffbffa39eb1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ProviderInterfaceIndexToNameResponder {
    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for ProviderInterfaceIndexToNameResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ProviderInterfaceIndexToNameResponder {
    type ControlHandle = ProviderControlHandle;

    fn control_handle(&self) -> &ProviderControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl ProviderInterfaceIndexToNameResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<&str, i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<&str, i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<&str, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            ProviderInterfaceIndexToNameResponse,
            i32,
        >>(
            result.map(|name| (name,)),
            self.tx_id,
            0x4d59a64fce98272f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ProviderInterfaceNameToIndexResponder {
    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for ProviderInterfaceNameToIndexResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ProviderInterfaceNameToIndexResponder {
    type ControlHandle = ProviderControlHandle;

    fn control_handle(&self) -> &ProviderControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl ProviderInterfaceNameToIndexResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            ProviderInterfaceNameToIndexResponse,
            i32,
        >>(
            result.map(|index| (index,)),
            self.tx_id,
            0x690cd8d2f2d650f8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ProviderInterfaceNameToFlagsResponder {
    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for ProviderInterfaceNameToFlagsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ProviderInterfaceNameToFlagsResponder {
    type ControlHandle = ProviderControlHandle;

    fn control_handle(&self) -> &ProviderControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl ProviderInterfaceNameToFlagsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<InterfaceFlags, i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<InterfaceFlags, i32>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<InterfaceFlags, i32>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            ProviderInterfaceNameToFlagsResponse,
            i32,
        >>(
            result.map(|flags| (flags,)),
            self.tx_id,
            0x25d0efcdb6671a0b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ProviderGetInterfaceAddressesResponder {
    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for ProviderGetInterfaceAddressesResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ProviderGetInterfaceAddressesResponder {
    type ControlHandle = ProviderControlHandle;

    fn control_handle(&self) -> &ProviderControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl ProviderGetInterfaceAddressesResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut interfaces: &[InterfaceAddresses]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(interfaces);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut interfaces: &[InterfaceAddresses],
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(interfaces);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut interfaces: &[InterfaceAddresses]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<ProviderGetInterfaceAddressesResponse>(
            (interfaces,),
            self.tx_id,
            0x2e7b9aaf327c870,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct StreamSocketMarker;

impl fidl::endpoints::ProtocolMarker for StreamSocketMarker {
    type Proxy = StreamSocketProxy;
    type RequestStream = StreamSocketRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = StreamSocketSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.posix.socket.StreamSocket";
}
impl fidl::endpoints::DiscoverableProtocolMarker for StreamSocketMarker {}
pub type StreamSocketListenResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type StreamSocketAcceptResult = Result<
    (Option<Box<fidl_fuchsia_net::SocketAddress>>, fidl::endpoints::ClientEnd<StreamSocketMarker>),
    fidl_fuchsia_posix::Errno,
>;
pub type StreamSocketGetInfoResult =
    Result<(Domain, StreamSocketProtocol), fidl_fuchsia_posix::Errno>;
pub type StreamSocketSetTcpNoDelayResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type StreamSocketGetTcpNoDelayResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type StreamSocketSetTcpMaxSegmentResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type StreamSocketGetTcpMaxSegmentResult = Result<u32, fidl_fuchsia_posix::Errno>;
pub type StreamSocketSetTcpCorkResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type StreamSocketGetTcpCorkResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type StreamSocketSetTcpKeepAliveIdleResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type StreamSocketGetTcpKeepAliveIdleResult = Result<u32, fidl_fuchsia_posix::Errno>;
pub type StreamSocketSetTcpKeepAliveIntervalResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type StreamSocketGetTcpKeepAliveIntervalResult = Result<u32, fidl_fuchsia_posix::Errno>;
pub type StreamSocketSetTcpKeepAliveCountResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type StreamSocketGetTcpKeepAliveCountResult = Result<u32, fidl_fuchsia_posix::Errno>;
pub type StreamSocketSetTcpSynCountResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type StreamSocketGetTcpSynCountResult = Result<u32, fidl_fuchsia_posix::Errno>;
pub type StreamSocketSetTcpLingerResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type StreamSocketGetTcpLingerResult = Result<OptionalUint32, fidl_fuchsia_posix::Errno>;
pub type StreamSocketSetTcpDeferAcceptResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type StreamSocketGetTcpDeferAcceptResult = Result<u32, fidl_fuchsia_posix::Errno>;
pub type StreamSocketSetTcpWindowClampResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type StreamSocketGetTcpWindowClampResult = Result<u32, fidl_fuchsia_posix::Errno>;
pub type StreamSocketGetTcpInfoResult = Result<TcpInfo, fidl_fuchsia_posix::Errno>;
pub type StreamSocketSetTcpQuickAckResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type StreamSocketGetTcpQuickAckResult = Result<bool, fidl_fuchsia_posix::Errno>;
pub type StreamSocketSetTcpCongestionResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type StreamSocketGetTcpCongestionResult =
    Result<TcpCongestionControl, fidl_fuchsia_posix::Errno>;
pub type StreamSocketSetTcpUserTimeoutResult = Result<(), fidl_fuchsia_posix::Errno>;
pub type StreamSocketGetTcpUserTimeoutResult = Result<u32, fidl_fuchsia_posix::Errno>;

pub trait StreamSocketProxyInterface: Send + Sync {
    fn r#clone(
        &self,
        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error>;
    type CloseResponseFut: std::future::Future<
            Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
        > + Send;
    fn r#close(&self) -> Self::CloseResponseFut;
    type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
    fn r#query(&self) -> Self::QueryResponseFut;
    type SetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketSetReuseAddressResult, fidl::Error>>
        + Send;
    fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
    type GetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketGetReuseAddressResult, fidl::Error>>
        + Send;
    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
    type GetErrorResponseFut: std::future::Future<Output = Result<BaseSocketGetErrorResult, fidl::Error>>
        + Send;
    fn r#get_error(&self) -> Self::GetErrorResponseFut;
    type SetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketSetBroadcastResult, fidl::Error>>
        + Send;
    fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
    type GetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketGetBroadcastResult, fidl::Error>>
        + Send;
    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
    type SetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetSendBufferResult, fidl::Error>>
        + Send;
    fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
    type GetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetSendBufferResult, fidl::Error>>
        + Send;
    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
    type SetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetReceiveBufferResult, fidl::Error>>
        + Send;
    fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
    type GetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetReceiveBufferResult, fidl::Error>>
        + Send;
    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
    type SetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketSetKeepAliveResult, fidl::Error>>
        + Send;
    fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
    type GetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketGetKeepAliveResult, fidl::Error>>
        + Send;
    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
    type SetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketSetOutOfBandInlineResult, fidl::Error>>
        + Send;
    fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
    type GetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketGetOutOfBandInlineResult, fidl::Error>>
        + Send;
    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
    type SetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketSetNoCheckResult, fidl::Error>>
        + Send;
    fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
    type GetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketGetNoCheckResult, fidl::Error>>
        + Send;
    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
    type SetLingerResponseFut: std::future::Future<Output = Result<BaseSocketSetLingerResult, fidl::Error>>
        + Send;
    fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
    type GetLingerResponseFut: std::future::Future<Output = Result<BaseSocketGetLingerResult, fidl::Error>>
        + Send;
    fn r#get_linger(&self) -> Self::GetLingerResponseFut;
    type SetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketSetReusePortResult, fidl::Error>>
        + Send;
    fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
    type GetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketGetReusePortResult, fidl::Error>>
        + Send;
    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
    type GetAcceptConnResponseFut: std::future::Future<Output = Result<BaseSocketGetAcceptConnResult, fidl::Error>>
        + Send;
    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
    type SetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToDeviceResult, fidl::Error>>
        + Send;
    fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
    type GetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToDeviceResult, fidl::Error>>
        + Send;
    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
    type SetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error>>
        + Send;
    fn r#set_bind_to_interface_index(&self, value: u64)
    -> Self::SetBindToInterfaceIndexResponseFut;
    type GetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error>>
        + Send;
    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
    type SetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketSetTimestampResult, fidl::Error>>
        + Send;
    fn r#set_timestamp(&self, value: TimestampOption) -> Self::SetTimestampResponseFut;
    type GetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketGetTimestampResult, fidl::Error>>
        + Send;
    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
    type SetMarkResponseFut: std::future::Future<Output = Result<BaseSocketSetMarkResult, fidl::Error>>
        + Send;
    fn r#set_mark(
        &self,
        domain: fidl_fuchsia_net::MarkDomain,
        mark: &OptionalUint32,
    ) -> Self::SetMarkResponseFut;
    type GetMarkResponseFut: std::future::Future<Output = Result<BaseSocketGetMarkResult, fidl::Error>>
        + Send;
    fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
    type GetCookieResponseFut: std::future::Future<Output = Result<BaseSocketGetCookieResult, fidl::Error>>
        + Send;
    fn r#get_cookie(&self) -> Self::GetCookieResponseFut;
    type BindResponseFut: std::future::Future<Output = Result<BaseNetworkSocketBindResult, fidl::Error>>
        + Send;
    fn r#bind(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut;
    type ConnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketConnectResult, fidl::Error>>
        + Send;
    fn r#connect(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut;
    type DisconnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDisconnectResult, fidl::Error>>
        + Send;
    fn r#disconnect(&self) -> Self::DisconnectResponseFut;
    type GetSockNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetSockNameResult, fidl::Error>>
        + Send;
    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut;
    type GetPeerNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetPeerNameResult, fidl::Error>>
        + Send;
    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut;
    type ShutdownResponseFut: std::future::Future<Output = Result<BaseNetworkSocketShutdownResult, fidl::Error>>
        + Send;
    fn r#shutdown(&self, mode: ShutdownMode) -> Self::ShutdownResponseFut;
    type SetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>>
        + Send;
    fn r#set_ip_type_of_service(&self, value: u8) -> Self::SetIpTypeOfServiceResponseFut;
    type GetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>>
        + Send;
    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut;
    type SetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTtlResult, fidl::Error>>
        + Send;
    fn r#set_ip_ttl(&self, value: &OptionalUint8) -> Self::SetIpTtlResponseFut;
    type GetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTtlResult, fidl::Error>>
        + Send;
    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut;
    type SetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>>
        + Send;
    fn r#set_ip_packet_info(&self, value: bool) -> Self::SetIpPacketInfoResponseFut;
    type GetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>>
        + Send;
    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut;
    type SetIpReceiveTypeOfServiceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error>,
        > + Send;
    fn r#set_ip_receive_type_of_service(
        &self,
        value: bool,
    ) -> Self::SetIpReceiveTypeOfServiceResponseFut;
    type GetIpReceiveTypeOfServiceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error>,
        > + Send;
    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut;
    type SetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>>
        + Send;
    fn r#set_ip_receive_ttl(&self, value: bool) -> Self::SetIpReceiveTtlResponseFut;
    type GetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>>
        + Send;
    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut;
    type SetIpMulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#set_ip_multicast_interface(
        &self,
        iface: u64,
        address: &fidl_fuchsia_net::Ipv4Address,
    ) -> Self::SetIpMulticastInterfaceResponseFut;
    type GetIpMulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut;
    type SetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>>
        + Send;
    fn r#set_ip_multicast_ttl(&self, value: &OptionalUint8) -> Self::SetIpMulticastTtlResponseFut;
    type GetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>>
        + Send;
    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut;
    type SetIpMulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#set_ip_multicast_loopback(&self, value: bool) -> Self::SetIpMulticastLoopbackResponseFut;
    type GetIpMulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut;
    type AddIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error>>
        + Send;
    fn r#add_ip_membership(
        &self,
        membership: &IpMulticastMembership,
    ) -> Self::AddIpMembershipResponseFut;
    type DropIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error>>
        + Send;
    fn r#drop_ip_membership(
        &self,
        membership: &IpMulticastMembership,
    ) -> Self::DropIpMembershipResponseFut;
    type SetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error>>
        + Send;
    fn r#set_ip_transparent(&self, value: bool) -> Self::SetIpTransparentResponseFut;
    type GetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error>>
        + Send;
    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut;
    type SetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
            Output = Result<
                BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
                fidl::Error,
            >,
        > + Send;
    fn r#set_ip_receive_original_destination_address(
        &self,
        value: bool,
    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut;
    type GetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
            Output = Result<
                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
                fidl::Error,
            >,
        > + Send;
    fn r#get_ip_receive_original_destination_address(
        &self,
    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut;
    type AddIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>>
        + Send;
    fn r#add_ipv6_membership(
        &self,
        membership: &Ipv6MulticastMembership,
    ) -> Self::AddIpv6MembershipResponseFut;
    type DropIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>>
        + Send;
    fn r#drop_ipv6_membership(
        &self,
        membership: &Ipv6MulticastMembership,
    ) -> Self::DropIpv6MembershipResponseFut;
    type SetIpv6MulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_multicast_interface(
        &self,
        value: u64,
    ) -> Self::SetIpv6MulticastInterfaceResponseFut;
    type GetIpv6MulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut;
    type SetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>>
        + Send;
    fn r#set_ipv6_unicast_hops(&self, value: &OptionalUint8)
    -> Self::SetIpv6UnicastHopsResponseFut;
    type GetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>>
        + Send;
    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut;
    type SetIpv6ReceiveHopLimitResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_receive_hop_limit(&self, value: bool) -> Self::SetIpv6ReceiveHopLimitResponseFut;
    type GetIpv6ReceiveHopLimitResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut;
    type SetIpv6MulticastHopsResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_multicast_hops(
        &self,
        value: &OptionalUint8,
    ) -> Self::SetIpv6MulticastHopsResponseFut;
    type GetIpv6MulticastHopsResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut;
    type SetIpv6MulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_multicast_loopback(
        &self,
        value: bool,
    ) -> Self::SetIpv6MulticastLoopbackResponseFut;
    type GetIpv6MulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut;
    type SetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error>>
        + Send;
    fn r#set_ipv6_only(&self, value: bool) -> Self::SetIpv6OnlyResponseFut;
    type GetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error>>
        + Send;
    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut;
    type SetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_receive_traffic_class(
        &self,
        value: bool,
    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut;
    type GetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut;
    type SetIpv6TrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_traffic_class(
        &self,
        value: &OptionalUint8,
    ) -> Self::SetIpv6TrafficClassResponseFut;
    type GetIpv6TrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut;
    type SetIpv6ReceivePacketInfoResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_receive_packet_info(
        &self,
        value: bool,
    ) -> Self::SetIpv6ReceivePacketInfoResponseFut;
    type GetIpv6ReceivePacketInfoResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut;
    type GetOriginalDestinationResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error>,
        > + Send;
    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut;
    type DescribeResponseFut: std::future::Future<Output = Result<StreamSocketDescribeResponse, fidl::Error>>
        + Send;
    fn r#describe(&self) -> Self::DescribeResponseFut;
    type ListenResponseFut: std::future::Future<Output = Result<StreamSocketListenResult, fidl::Error>>
        + Send;
    fn r#listen(&self, backlog: i16) -> Self::ListenResponseFut;
    type AcceptResponseFut: std::future::Future<Output = Result<StreamSocketAcceptResult, fidl::Error>>
        + Send;
    fn r#accept(&self, want_addr: bool) -> Self::AcceptResponseFut;
    type GetInfoResponseFut: std::future::Future<Output = Result<StreamSocketGetInfoResult, fidl::Error>>
        + Send;
    fn r#get_info(&self) -> Self::GetInfoResponseFut;
    type SetTcpNoDelayResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpNoDelayResult, fidl::Error>>
        + Send;
    fn r#set_tcp_no_delay(&self, value: bool) -> Self::SetTcpNoDelayResponseFut;
    type GetTcpNoDelayResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpNoDelayResult, fidl::Error>>
        + Send;
    fn r#get_tcp_no_delay(&self) -> Self::GetTcpNoDelayResponseFut;
    type SetTcpMaxSegmentResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpMaxSegmentResult, fidl::Error>>
        + Send;
    fn r#set_tcp_max_segment(&self, value_bytes: u32) -> Self::SetTcpMaxSegmentResponseFut;
    type GetTcpMaxSegmentResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpMaxSegmentResult, fidl::Error>>
        + Send;
    fn r#get_tcp_max_segment(&self) -> Self::GetTcpMaxSegmentResponseFut;
    type SetTcpCorkResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpCorkResult, fidl::Error>>
        + Send;
    fn r#set_tcp_cork(&self, value: bool) -> Self::SetTcpCorkResponseFut;
    type GetTcpCorkResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpCorkResult, fidl::Error>>
        + Send;
    fn r#get_tcp_cork(&self) -> Self::GetTcpCorkResponseFut;
    type SetTcpKeepAliveIdleResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpKeepAliveIdleResult, fidl::Error>>
        + Send;
    fn r#set_tcp_keep_alive_idle(&self, value_secs: u32) -> Self::SetTcpKeepAliveIdleResponseFut;
    type GetTcpKeepAliveIdleResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpKeepAliveIdleResult, fidl::Error>>
        + Send;
    fn r#get_tcp_keep_alive_idle(&self) -> Self::GetTcpKeepAliveIdleResponseFut;
    type SetTcpKeepAliveIntervalResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpKeepAliveIntervalResult, fidl::Error>>
        + Send;
    fn r#set_tcp_keep_alive_interval(
        &self,
        value_secs: u32,
    ) -> Self::SetTcpKeepAliveIntervalResponseFut;
    type GetTcpKeepAliveIntervalResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpKeepAliveIntervalResult, fidl::Error>>
        + Send;
    fn r#get_tcp_keep_alive_interval(&self) -> Self::GetTcpKeepAliveIntervalResponseFut;
    type SetTcpKeepAliveCountResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpKeepAliveCountResult, fidl::Error>>
        + Send;
    fn r#set_tcp_keep_alive_count(&self, value: u32) -> Self::SetTcpKeepAliveCountResponseFut;
    type GetTcpKeepAliveCountResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpKeepAliveCountResult, fidl::Error>>
        + Send;
    fn r#get_tcp_keep_alive_count(&self) -> Self::GetTcpKeepAliveCountResponseFut;
    type SetTcpSynCountResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpSynCountResult, fidl::Error>>
        + Send;
    fn r#set_tcp_syn_count(&self, value: u32) -> Self::SetTcpSynCountResponseFut;
    type GetTcpSynCountResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpSynCountResult, fidl::Error>>
        + Send;
    fn r#get_tcp_syn_count(&self) -> Self::GetTcpSynCountResponseFut;
    type SetTcpLingerResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpLingerResult, fidl::Error>>
        + Send;
    fn r#set_tcp_linger(&self, value_secs: &OptionalUint32) -> Self::SetTcpLingerResponseFut;
    type GetTcpLingerResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpLingerResult, fidl::Error>>
        + Send;
    fn r#get_tcp_linger(&self) -> Self::GetTcpLingerResponseFut;
    type SetTcpDeferAcceptResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpDeferAcceptResult, fidl::Error>>
        + Send;
    fn r#set_tcp_defer_accept(&self, value_secs: u32) -> Self::SetTcpDeferAcceptResponseFut;
    type GetTcpDeferAcceptResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpDeferAcceptResult, fidl::Error>>
        + Send;
    fn r#get_tcp_defer_accept(&self) -> Self::GetTcpDeferAcceptResponseFut;
    type SetTcpWindowClampResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpWindowClampResult, fidl::Error>>
        + Send;
    fn r#set_tcp_window_clamp(&self, value: u32) -> Self::SetTcpWindowClampResponseFut;
    type GetTcpWindowClampResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpWindowClampResult, fidl::Error>>
        + Send;
    fn r#get_tcp_window_clamp(&self) -> Self::GetTcpWindowClampResponseFut;
    type GetTcpInfoResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpInfoResult, fidl::Error>>
        + Send;
    fn r#get_tcp_info(&self) -> Self::GetTcpInfoResponseFut;
    type SetTcpQuickAckResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpQuickAckResult, fidl::Error>>
        + Send;
    fn r#set_tcp_quick_ack(&self, value: bool) -> Self::SetTcpQuickAckResponseFut;
    type GetTcpQuickAckResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpQuickAckResult, fidl::Error>>
        + Send;
    fn r#get_tcp_quick_ack(&self) -> Self::GetTcpQuickAckResponseFut;
    type SetTcpCongestionResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpCongestionResult, fidl::Error>>
        + Send;
    fn r#set_tcp_congestion(
        &self,
        value: TcpCongestionControl,
    ) -> Self::SetTcpCongestionResponseFut;
    type GetTcpCongestionResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpCongestionResult, fidl::Error>>
        + Send;
    fn r#get_tcp_congestion(&self) -> Self::GetTcpCongestionResponseFut;
    type SetTcpUserTimeoutResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpUserTimeoutResult, fidl::Error>>
        + Send;
    fn r#set_tcp_user_timeout(&self, value_millis: u32) -> Self::SetTcpUserTimeoutResponseFut;
    type GetTcpUserTimeoutResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpUserTimeoutResult, fidl::Error>>
        + Send;
    fn r#get_tcp_user_timeout(&self) -> Self::GetTcpUserTimeoutResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct StreamSocketSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for StreamSocketSynchronousProxy {
    type Proxy = StreamSocketProxy;
    type Protocol = StreamSocketMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl StreamSocketSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <StreamSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketEvent, fidl::Error> {
        StreamSocketEvent::decode(self.client.wait_for_event(deadline)?)
    }

    pub fn r#clone(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_unknown::QueryableQueryResponse,
        >(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.protocol)
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#set_reuse_address(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetReuseAddressRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x1fd74ee8b9a4a876,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#get_reuse_address(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetReuseAddressResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Get `SOL_SOCKET` -> `SO_ERROR`.
    /// Returns the last error if there is an error set on the socket.
    pub fn r#get_error(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x5aad39b33e5f6ebb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#set_broadcast(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetBroadcastRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x6023e081ce3cd947,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#get_broadcast(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetBroadcastResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x68796fc556f9780d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#set_send_buffer(
        &self,
        mut value_bytes: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetSendBufferRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value_bytes,),
                0x756eac32d73a7a70,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#get_send_buffer(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetSendBufferResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value_bytes))
    }

    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#set_receive_buffer(
        &self,
        mut value_bytes: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseSocketSetReceiveBufferRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value_bytes,),
                    0x6b0cf2f1919c7001,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#get_receive_buffer(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetReceiveBufferResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value_bytes))
    }

    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#set_keep_alive(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetKeepAliveRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x572df8f0b920d2c7,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#get_keep_alive(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetKeepAliveResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x2dd29d3215f2c9d2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#set_out_of_band_inline(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseSocketSetOutOfBandInlineRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x3ecb49968bee439,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#get_out_of_band_inline(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetOutOfBandInlineResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#set_no_check(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetNoCheckRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x6bbf00c53a4c78c2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#get_no_check(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetNoCheckResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x2cd4249286417694,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#set_linger(
        &self,
        mut linger: bool,
        mut length_secs: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetLingerRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (linger, length_secs),
                0x45386351246e998e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#get_linger(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetLingerResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x48eb20fc5ccb0e45,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| (x.linger, x.length_secs)))
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#set_reuse_port(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetReusePortRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x24dd3e5cb36d9ccb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#get_reuse_port(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetReusePortResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x7a112c1ab54ff828,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
    pub fn r#get_accept_conn(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetAcceptConnResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#set_bind_to_device(
        &self,
        mut value: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetBindToDeviceRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x2118b483f28aafc4,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#get_bind_to_device(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetBindToDeviceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    /// If `value` is 0, this clears the bound interface.
    pub fn r#set_bind_to_interface_index(
        &self,
        mut value: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x6e387a0def00821,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    pub fn r#get_bind_to_interface_index(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetBindToInterfaceIndexResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#set_timestamp(
        &self,
        mut value: TimestampOption,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetTimestampRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x285d6516c263d839,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#get_timestamp(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetTimestampResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x49f2fffbbcc2bd27,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be set independently in each domain.
    pub fn r#set_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        mut mark: &OptionalUint32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetMarkRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (domain, mark),
                0x6ead6de09f653236,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be retrieved independently in each domain.
    pub fn r#get_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketGetMarkRequest, fidl::encoding::ResultType<
                BaseSocketGetMarkResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (domain,),
                0x57a2752c61d93d47,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.mark))
    }

    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
    pub fn r#get_cookie(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetCookieResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetCookieResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x2c2f47fd8f924e52,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Sets the local address used for the socket.
    pub fn r#bind(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketBindRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (addr,),
                0x4bc6400ae92125d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Initiates a connection to a remote address.
    pub fn r#connect(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketConnectRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (addr,),
                0x5f05f19bfdd38871,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Clears connection information from this socket.
    pub fn r#disconnect(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x74e63b91f7b29b2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Retrieves the local socket address.
    pub fn r#get_sock_name(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetSockNameResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x475f23f84a1a4f85, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.addr))
    }

    /// Retrieves the remote socket address.
    pub fn r#get_peer_name(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetPeerNameResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x1ffecf4bd5b6432e, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.addr))
    }

    /// Shuts down part of the socket.
    pub fn r#shutdown(
        &self,
        mut mode: ShutdownMode,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketShutdownRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (mode,),
                0x247f38b6db68c336,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IP` -> `IP_TOS`.
    pub fn r#set_ip_type_of_service(
        &self,
        mut value: u8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpTypeOfServiceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x995c600475b6d46,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_TOS`.
    pub fn r#get_ip_type_of_service(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpTypeOfServiceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x3814a04259f75fcb, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_TTL`.
    pub fn r#set_ip_ttl(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketSetIpTtlRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x29e2424b433ae1ef,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_TTL`.
    pub fn r#get_ip_ttl(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpTtlResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x47e47fa1f24da471, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#set_ip_packet_info(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x392d16bee20c0e16,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#get_ip_packet_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpPacketInfoResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x54b505f242280740, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#set_ip_receive_type_of_service(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x6c4f6714995f84ef,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#get_ip_receive_type_of_service(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4158ba7dc2795960, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#set_ip_receive_ttl(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x46f15be0ce0ab82b,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#get_ip_receive_ttl(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpReceiveTtlResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x678ddd5a5dfa2eb5, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#set_ip_multicast_interface(
        &self,
        mut iface: u64,
        mut address: &fidl_fuchsia_net::Ipv4Address,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpMulticastInterfaceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (iface, address,),
            0x752fbfa9b12befe,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#get_ip_multicast_interface(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpMulticastInterfaceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x320bd14c4df046c4, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#set_ip_multicast_ttl(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x63134d53772916a1,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#get_ip_multicast_ttl(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpMulticastTtlResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4665cd378f39e1a, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#set_ip_multicast_loopback(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpMulticastLoopbackRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x20c55c11f00943ea,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#get_ip_multicast_loopback(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpMulticastLoopbackResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x3b6b26ff558298f2, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
    pub fn r#add_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (membership,),
                    0x76bc7df115a3b4d0,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
    pub fn r#drop_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (membership,),
                    0x2888f3099188d03,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#set_ip_transparent(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x1ae532b0c066e3a0,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#get_ip_transparent(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpTransparentResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x51d43695962ebfb5, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#set_ip_receive_original_destination_address(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x4722b4ce52f7840,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#get_ip_receive_original_destination_address(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x2a0e7dc5d6bfdfe9, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
    pub fn r#add_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (membership,),
                    0x7c94727acb4ea4b3,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
    pub fn r#drop_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketDropIpv6MembershipRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (membership,),
            0x42104c70ccaba304,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#set_ipv6_multicast_interface(
        &self,
        mut value: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x135f76db3774ab3b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#get_ipv6_multicast_interface(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x1f26fcdd348f1882, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#set_ipv6_unicast_hops(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6UnicastHopsRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x157d51e98f462859,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#get_ipv6_unicast_hops(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6UnicastHopsResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x21f4641cad8bd8d2, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#set_ipv6_receive_hop_limit(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x5c24808ed2e84a1e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#get_ipv6_receive_hop_limit(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x341e06689885b4c0, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#set_ipv6_multicast_hops(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6MulticastHopsRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x25b9cd4d181f82c1,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#get_ipv6_multicast_hops(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6MulticastHopsResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x52916948a365012a, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#set_ipv6_multicast_loopback(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x55701c409ff41b40,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#get_ipv6_multicast_loopback(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4415b701fde319c3, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#set_ipv6_only(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x4873f1364758cbba,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#get_ipv6_only(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6OnlyResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4aa3340a1a26b89c, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#set_ipv6_receive_traffic_class(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x58f07c8788d099a0,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#get_ipv6_receive_traffic_class(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x2e334df1da553ffa, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
    pub fn r#set_ipv6_traffic_class(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6TrafficClassRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x6af077800c5a0b4f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
    pub fn r#get_ipv6_traffic_class(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6TrafficClassResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x6baf6eed8fc2f04, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#set_ipv6_receive_packet_info(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x19259775b1a92768,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#get_ipv6_receive_packet_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x7acd4a2775baec75, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
    pub fn r#get_original_destination(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetOriginalDestinationResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x38bf28f0dafdbac0, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    pub fn r#describe(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketDescribeResponse, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, StreamSocketDescribeResponse>(
                (),
                0x29e22969a7dadc32,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Begins listening for new incoming connections. At most `backlog`
    /// connections will be buffered.
    pub fn r#listen(
        &self,
        mut backlog: i16,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketListenResult, fidl::Error> {
        let _response =
            self.client.send_query::<StreamSocketListenRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (backlog,),
                0x3d0a65ced3d10108,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Accepts a buffered incoming connection.
    pub fn r#accept(
        &self,
        mut want_addr: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketAcceptResult, fidl::Error> {
        let _response =
            self.client.send_query::<StreamSocketAcceptRequest, fidl::encoding::ResultType<
                StreamSocketAcceptResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (want_addr,),
                0x5ab7ad620424c163,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| (x.addr, x.s)))
    }

    /// Retrieves creation information from the socket.
    pub fn r#get_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketGetInfoResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                StreamSocketGetInfoResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x87cfa55d19f878f,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| (x.domain, x.proto)))
    }

    /// Set `SOL_TCP` -> `TCP_NODELAY`.
    pub fn r#set_tcp_no_delay(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketSetTcpNoDelayResult, fidl::Error> {
        let _response =
            self.client.send_query::<StreamSocketSetTcpNoDelayRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x5a59b778f7333ada,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_TCP` -> `TCP_NODELAY`.
    pub fn r#get_tcp_no_delay(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketGetTcpNoDelayResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                StreamSocketGetTcpNoDelayResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0xac219a3218b0799, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_TCP` -> `TCP_MAXSEG`.
    pub fn r#set_tcp_max_segment(
        &self,
        mut value_bytes: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketSetTcpMaxSegmentResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<StreamSocketSetTcpMaxSegmentRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value_bytes,),
                    0xb3d30c498266d18,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_TCP` -> `TCP_MAXSEG`.
    pub fn r#get_tcp_max_segment(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketGetTcpMaxSegmentResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                StreamSocketGetTcpMaxSegmentResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x637404d1b4b9982c, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value_bytes))
    }

    /// Set `SOL_TCP` -> `TCP_CORK`.
    pub fn r#set_tcp_cork(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketSetTcpCorkResult, fidl::Error> {
        let _response =
            self.client.send_query::<StreamSocketSetTcpCorkRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x62e26891541143a0,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_TCP` -> `TCP_CORK`.
    pub fn r#get_tcp_cork(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketGetTcpCorkResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                StreamSocketGetTcpCorkResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x435bb232e0e74f32,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_TCP` -> `TCP_KEEPIDLE`.
    pub fn r#set_tcp_keep_alive_idle(
        &self,
        mut value_secs: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketSetTcpKeepAliveIdleResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<StreamSocketSetTcpKeepAliveIdleRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value_secs,),
                    0x196d053d8363c42,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_TCP` -> `TCP_KEEPIDLE`.
    pub fn r#get_tcp_keep_alive_idle(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketGetTcpKeepAliveIdleResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                StreamSocketGetTcpKeepAliveIdleResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x35ec58564879dac, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value_secs))
    }

    /// Set `SOL_TCP` -> `TCP_KEEPINTVL`.
    pub fn r#set_tcp_keep_alive_interval(
        &self,
        mut value_secs: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketSetTcpKeepAliveIntervalResult, fidl::Error> {
        let _response = self.client.send_query::<
            StreamSocketSetTcpKeepAliveIntervalRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value_secs,),
            0x485ffbc2da1243f2,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_TCP` -> `TCP_KEEPINTVL`.
    pub fn r#get_tcp_keep_alive_interval(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketGetTcpKeepAliveIntervalResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                StreamSocketGetTcpKeepAliveIntervalResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x264eaf46306b284, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value_secs))
    }

    /// Set `SOL_TCP` -> `TCP_KEEPCNT`.
    pub fn r#set_tcp_keep_alive_count(
        &self,
        mut value: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketSetTcpKeepAliveCountResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<StreamSocketSetTcpKeepAliveCountRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x2ab2e8c111708421,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_TCP` -> `TCP_KEEPCNT`.
    pub fn r#get_tcp_keep_alive_count(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketGetTcpKeepAliveCountResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                StreamSocketGetTcpKeepAliveCountResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x2f176ae271fe7a09, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_TCP` -> `TCP_SYNCNT`.
    pub fn r#set_tcp_syn_count(
        &self,
        mut value: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketSetTcpSynCountResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<StreamSocketSetTcpSynCountRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x4dcd6ab5573c1eb3,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_TCP` -> `TCP_SYNCNT`.
    pub fn r#get_tcp_syn_count(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketGetTcpSynCountResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                StreamSocketGetTcpSynCountResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x7d457cba8f5f3ee6, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_TCP` -> `TCP_LINGER2`.
    pub fn r#set_tcp_linger(
        &self,
        mut value_secs: &OptionalUint32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketSetTcpLingerResult, fidl::Error> {
        let _response =
            self.client.send_query::<StreamSocketSetTcpLingerRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value_secs,),
                0xd5cc1e8654d36e4,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_TCP` -> `TCP_LINGER2`.
    pub fn r#get_tcp_linger(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketGetTcpLingerResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                StreamSocketGetTcpLingerResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0xad870d311cf30eb, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value_secs))
    }

    /// Set `SOL_TCP` -> `TCP_DEFER_ACCEPT`.
    pub fn r#set_tcp_defer_accept(
        &self,
        mut value_secs: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketSetTcpDeferAcceptResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<StreamSocketSetTcpDeferAcceptRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value_secs,),
                    0x15092f181e57c404,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_TCP` -> `TCP_DEFER_ACCEPT`.
    pub fn r#get_tcp_defer_accept(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketGetTcpDeferAcceptResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                StreamSocketGetTcpDeferAcceptResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x64589790842cb7c6, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value_secs))
    }

    /// Set `SOL_TCP` -> `TCP_WINDOW_CLAMP`.
    pub fn r#set_tcp_window_clamp(
        &self,
        mut value: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketSetTcpWindowClampResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<StreamSocketSetTcpWindowClampRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x4a26ce07d847f1c6,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_TCP` -> `TCP_WINDOW_CLAMP`.
    pub fn r#get_tcp_window_clamp(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketGetTcpWindowClampResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                StreamSocketGetTcpWindowClampResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x2df6b636bf0a6a4e, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Get `SOL_TCP` -> `TCP_INFO`.
    pub fn r#get_tcp_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketGetTcpInfoResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                StreamSocketGetTcpInfoResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x1ffb123d9f03ead2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.info))
    }

    /// Set `SOL_TCP` -> `TCP_QUICKACK`.
    pub fn r#set_tcp_quick_ack(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketSetTcpQuickAckResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<StreamSocketSetTcpQuickAckRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x6fa811be8fde7457,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_TCP` -> `TCP_QUICKACK`.
    pub fn r#get_tcp_quick_ack(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketGetTcpQuickAckResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                StreamSocketGetTcpQuickAckResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x7356a949bef2df32, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_TCP` -> `TCP_CONGESTION`.
    pub fn r#set_tcp_congestion(
        &self,
        mut value: TcpCongestionControl,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketSetTcpCongestionResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<StreamSocketSetTcpCongestionRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x7924c6eabde7819e,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_TCP` -> `TCP_CONGESTION`.
    pub fn r#get_tcp_congestion(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketGetTcpCongestionResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                StreamSocketGetTcpCongestionResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x11e16397e1b72a47, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_TCP` -> `TCP_USER_TIMEOUT`.
    pub fn r#set_tcp_user_timeout(
        &self,
        mut value_millis: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketSetTcpUserTimeoutResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<StreamSocketSetTcpUserTimeoutRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value_millis,),
                    0x6b459e81c3741a60,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_TCP` -> `TCP_USER_TIMEOUT`.
    pub fn r#get_tcp_user_timeout(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<StreamSocketGetTcpUserTimeoutResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                StreamSocketGetTcpUserTimeoutResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x24bbd5858ad8c380, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value_millis))
    }
}

#[cfg(target_os = "fuchsia")]
impl From<StreamSocketSynchronousProxy> for zx::Handle {
    fn from(value: StreamSocketSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for StreamSocketSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for StreamSocketSynchronousProxy {
    type Protocol = StreamSocketMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<StreamSocketMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct StreamSocketProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for StreamSocketProxy {
    type Protocol = StreamSocketMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl StreamSocketProxy {
    /// Create a new Proxy for fuchsia.posix.socket/StreamSocket.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <StreamSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> StreamSocketEventStream {
        StreamSocketEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#clone(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        StreamSocketProxyInterface::r#clone(self, request)
    }

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#close(self)
    }

    pub fn r#query(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        StreamSocketProxyInterface::r#query(self)
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#set_reuse_address(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_reuse_address(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#get_reuse_address(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_reuse_address(self)
    }

    /// Get `SOL_SOCKET` -> `SO_ERROR`.
    /// Returns the last error if there is an error set on the socket.
    pub fn r#get_error(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetErrorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_error(self)
    }

    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#set_broadcast(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_broadcast(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#get_broadcast(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_broadcast(self)
    }

    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#set_send_buffer(
        &self,
        mut value_bytes: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_send_buffer(self, value_bytes)
    }

    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#get_send_buffer(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_send_buffer(self)
    }

    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#set_receive_buffer(
        &self,
        mut value_bytes: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_receive_buffer(self, value_bytes)
    }

    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#get_receive_buffer(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_receive_buffer(self)
    }

    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#set_keep_alive(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_keep_alive(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#get_keep_alive(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_keep_alive(self)
    }

    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#set_out_of_band_inline(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_out_of_band_inline(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#get_out_of_band_inline(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_out_of_band_inline(self)
    }

    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#set_no_check(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_no_check(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#get_no_check(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_no_check(self)
    }

    /// Set `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#set_linger(
        &self,
        mut linger: bool,
        mut length_secs: u32,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_linger(self, linger, length_secs)
    }

    /// Get `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#get_linger(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_linger(self)
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#set_reuse_port(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_reuse_port(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#get_reuse_port(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_reuse_port(self)
    }

    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
    pub fn r#get_accept_conn(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetAcceptConnResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_accept_conn(self)
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#set_bind_to_device(
        &self,
        mut value: &str,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_bind_to_device(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#get_bind_to_device(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_bind_to_device(self)
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    /// If `value` is 0, this clears the bound interface.
    pub fn r#set_bind_to_interface_index(
        &self,
        mut value: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_bind_to_interface_index(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    pub fn r#get_bind_to_interface_index(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_bind_to_interface_index(self)
    }

    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#set_timestamp(
        &self,
        mut value: TimestampOption,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_timestamp(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#get_timestamp(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_timestamp(self)
    }

    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be set independently in each domain.
    pub fn r#set_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        mut mark: &OptionalUint32,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_mark(self, domain, mark)
    }

    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be retrieved independently in each domain.
    pub fn r#get_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_mark(self, domain)
    }

    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
    pub fn r#get_cookie(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetCookieResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_cookie(self)
    }

    /// Sets the local address used for the socket.
    pub fn r#bind(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketBindResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#bind(self, addr)
    }

    /// Initiates a connection to a remote address.
    pub fn r#connect(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#connect(self, addr)
    }

    /// Clears connection information from this socket.
    pub fn r#disconnect(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketDisconnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#disconnect(self)
    }

    /// Retrieves the local socket address.
    pub fn r#get_sock_name(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetSockNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_sock_name(self)
    }

    /// Retrieves the remote socket address.
    pub fn r#get_peer_name(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetPeerNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_peer_name(self)
    }

    /// Shuts down part of the socket.
    pub fn r#shutdown(
        &self,
        mut mode: ShutdownMode,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketShutdownResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#shutdown(self, mode)
    }

    /// Set `SOL_IP` -> `IP_TOS`.
    pub fn r#set_ip_type_of_service(
        &self,
        mut value: u8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ip_type_of_service(self, value)
    }

    /// Get `SOL_IP` -> `IP_TOS`.
    pub fn r#get_ip_type_of_service(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ip_type_of_service(self)
    }

    /// Set `SOL_IP` -> `IP_TTL`.
    pub fn r#set_ip_ttl(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ip_ttl(self, value)
    }

    /// Get `SOL_IP` -> `IP_TTL`.
    pub fn r#get_ip_ttl(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ip_ttl(self)
    }

    /// Set `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#set_ip_packet_info(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ip_packet_info(self, value)
    }

    /// Get `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#get_ip_packet_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ip_packet_info(self)
    }

    /// Set `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#set_ip_receive_type_of_service(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ip_receive_type_of_service(self, value)
    }

    /// Get `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#get_ip_receive_type_of_service(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ip_receive_type_of_service(self)
    }

    /// Set `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#set_ip_receive_ttl(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ip_receive_ttl(self, value)
    }

    /// Get `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#get_ip_receive_ttl(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ip_receive_ttl(self)
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#set_ip_multicast_interface(
        &self,
        mut iface: u64,
        mut address: &fidl_fuchsia_net::Ipv4Address,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ip_multicast_interface(self, iface, address)
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#get_ip_multicast_interface(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ip_multicast_interface(self)
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#set_ip_multicast_ttl(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ip_multicast_ttl(self, value)
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#get_ip_multicast_ttl(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ip_multicast_ttl(self)
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#set_ip_multicast_loopback(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ip_multicast_loopback(self, value)
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#get_ip_multicast_loopback(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ip_multicast_loopback(self)
    }

    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
    pub fn r#add_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#add_ip_membership(self, membership)
    }

    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
    pub fn r#drop_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#drop_ip_membership(self, membership)
    }

    /// Set `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#set_ip_transparent(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ip_transparent(self, value)
    }

    /// Get `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#get_ip_transparent(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ip_transparent(self)
    }

    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#set_ip_receive_original_destination_address(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ip_receive_original_destination_address(self, value)
    }

    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#get_ip_receive_original_destination_address(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ip_receive_original_destination_address(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
    pub fn r#add_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#add_ipv6_membership(self, membership)
    }

    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
    pub fn r#drop_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#drop_ipv6_membership(self, membership)
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#set_ipv6_multicast_interface(
        &self,
        mut value: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ipv6_multicast_interface(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#get_ipv6_multicast_interface(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ipv6_multicast_interface(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#set_ipv6_unicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ipv6_unicast_hops(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#get_ipv6_unicast_hops(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ipv6_unicast_hops(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#set_ipv6_receive_hop_limit(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ipv6_receive_hop_limit(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#get_ipv6_receive_hop_limit(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ipv6_receive_hop_limit(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#set_ipv6_multicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ipv6_multicast_hops(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#get_ipv6_multicast_hops(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ipv6_multicast_hops(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#set_ipv6_multicast_loopback(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ipv6_multicast_loopback(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#get_ipv6_multicast_loopback(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ipv6_multicast_loopback(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#set_ipv6_only(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ipv6_only(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#get_ipv6_only(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ipv6_only(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#set_ipv6_receive_traffic_class(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ipv6_receive_traffic_class(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#get_ipv6_receive_traffic_class(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ipv6_receive_traffic_class(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
    pub fn r#set_ipv6_traffic_class(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ipv6_traffic_class(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
    pub fn r#get_ipv6_traffic_class(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ipv6_traffic_class(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#set_ipv6_receive_packet_info(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_ipv6_receive_packet_info(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#get_ipv6_receive_packet_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_ipv6_receive_packet_info(self)
    }

    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
    pub fn r#get_original_destination(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetOriginalDestinationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_original_destination(self)
    }

    pub fn r#describe(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketDescribeResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#describe(self)
    }

    /// Begins listening for new incoming connections. At most `backlog`
    /// connections will be buffered.
    pub fn r#listen(
        &self,
        mut backlog: i16,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketListenResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#listen(self, backlog)
    }

    /// Accepts a buffered incoming connection.
    pub fn r#accept(
        &self,
        mut want_addr: bool,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketAcceptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#accept(self, want_addr)
    }

    /// Retrieves creation information from the socket.
    pub fn r#get_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketGetInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_info(self)
    }

    /// Set `SOL_TCP` -> `TCP_NODELAY`.
    pub fn r#set_tcp_no_delay(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketSetTcpNoDelayResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_tcp_no_delay(self, value)
    }

    /// Get `SOL_TCP` -> `TCP_NODELAY`.
    pub fn r#get_tcp_no_delay(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketGetTcpNoDelayResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_tcp_no_delay(self)
    }

    /// Set `SOL_TCP` -> `TCP_MAXSEG`.
    pub fn r#set_tcp_max_segment(
        &self,
        mut value_bytes: u32,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketSetTcpMaxSegmentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_tcp_max_segment(self, value_bytes)
    }

    /// Get `SOL_TCP` -> `TCP_MAXSEG`.
    pub fn r#get_tcp_max_segment(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketGetTcpMaxSegmentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_tcp_max_segment(self)
    }

    /// Set `SOL_TCP` -> `TCP_CORK`.
    pub fn r#set_tcp_cork(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketSetTcpCorkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_tcp_cork(self, value)
    }

    /// Get `SOL_TCP` -> `TCP_CORK`.
    pub fn r#get_tcp_cork(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketGetTcpCorkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_tcp_cork(self)
    }

    /// Set `SOL_TCP` -> `TCP_KEEPIDLE`.
    pub fn r#set_tcp_keep_alive_idle(
        &self,
        mut value_secs: u32,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketSetTcpKeepAliveIdleResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_tcp_keep_alive_idle(self, value_secs)
    }

    /// Get `SOL_TCP` -> `TCP_KEEPIDLE`.
    pub fn r#get_tcp_keep_alive_idle(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketGetTcpKeepAliveIdleResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_tcp_keep_alive_idle(self)
    }

    /// Set `SOL_TCP` -> `TCP_KEEPINTVL`.
    pub fn r#set_tcp_keep_alive_interval(
        &self,
        mut value_secs: u32,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketSetTcpKeepAliveIntervalResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_tcp_keep_alive_interval(self, value_secs)
    }

    /// Get `SOL_TCP` -> `TCP_KEEPINTVL`.
    pub fn r#get_tcp_keep_alive_interval(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketGetTcpKeepAliveIntervalResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_tcp_keep_alive_interval(self)
    }

    /// Set `SOL_TCP` -> `TCP_KEEPCNT`.
    pub fn r#set_tcp_keep_alive_count(
        &self,
        mut value: u32,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketSetTcpKeepAliveCountResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_tcp_keep_alive_count(self, value)
    }

    /// Get `SOL_TCP` -> `TCP_KEEPCNT`.
    pub fn r#get_tcp_keep_alive_count(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketGetTcpKeepAliveCountResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_tcp_keep_alive_count(self)
    }

    /// Set `SOL_TCP` -> `TCP_SYNCNT`.
    pub fn r#set_tcp_syn_count(
        &self,
        mut value: u32,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketSetTcpSynCountResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_tcp_syn_count(self, value)
    }

    /// Get `SOL_TCP` -> `TCP_SYNCNT`.
    pub fn r#get_tcp_syn_count(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketGetTcpSynCountResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_tcp_syn_count(self)
    }

    /// Set `SOL_TCP` -> `TCP_LINGER2`.
    pub fn r#set_tcp_linger(
        &self,
        mut value_secs: &OptionalUint32,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketSetTcpLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_tcp_linger(self, value_secs)
    }

    /// Get `SOL_TCP` -> `TCP_LINGER2`.
    pub fn r#get_tcp_linger(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketGetTcpLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_tcp_linger(self)
    }

    /// Set `SOL_TCP` -> `TCP_DEFER_ACCEPT`.
    pub fn r#set_tcp_defer_accept(
        &self,
        mut value_secs: u32,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketSetTcpDeferAcceptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_tcp_defer_accept(self, value_secs)
    }

    /// Get `SOL_TCP` -> `TCP_DEFER_ACCEPT`.
    pub fn r#get_tcp_defer_accept(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketGetTcpDeferAcceptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_tcp_defer_accept(self)
    }

    /// Set `SOL_TCP` -> `TCP_WINDOW_CLAMP`.
    pub fn r#set_tcp_window_clamp(
        &self,
        mut value: u32,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketSetTcpWindowClampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_tcp_window_clamp(self, value)
    }

    /// Get `SOL_TCP` -> `TCP_WINDOW_CLAMP`.
    pub fn r#get_tcp_window_clamp(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketGetTcpWindowClampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_tcp_window_clamp(self)
    }

    /// Get `SOL_TCP` -> `TCP_INFO`.
    pub fn r#get_tcp_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketGetTcpInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_tcp_info(self)
    }

    /// Set `SOL_TCP` -> `TCP_QUICKACK`.
    pub fn r#set_tcp_quick_ack(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketSetTcpQuickAckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_tcp_quick_ack(self, value)
    }

    /// Get `SOL_TCP` -> `TCP_QUICKACK`.
    pub fn r#get_tcp_quick_ack(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketGetTcpQuickAckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_tcp_quick_ack(self)
    }

    /// Set `SOL_TCP` -> `TCP_CONGESTION`.
    pub fn r#set_tcp_congestion(
        &self,
        mut value: TcpCongestionControl,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketSetTcpCongestionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_tcp_congestion(self, value)
    }

    /// Get `SOL_TCP` -> `TCP_CONGESTION`.
    pub fn r#get_tcp_congestion(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketGetTcpCongestionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_tcp_congestion(self)
    }

    /// Set `SOL_TCP` -> `TCP_USER_TIMEOUT`.
    pub fn r#set_tcp_user_timeout(
        &self,
        mut value_millis: u32,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketSetTcpUserTimeoutResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#set_tcp_user_timeout(self, value_millis)
    }

    /// Get `SOL_TCP` -> `TCP_USER_TIMEOUT`.
    pub fn r#get_tcp_user_timeout(
        &self,
    ) -> fidl::client::QueryResponseFut<
        StreamSocketGetTcpUserTimeoutResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        StreamSocketProxyInterface::r#get_tcp_user_timeout(self)
    }
}

impl StreamSocketProxyInterface for StreamSocketProxy {
    fn r#clone(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type CloseResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#close(&self) -> Self::CloseResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5ac5d459ad7f657e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_unknown::CloseableCloseResult,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryResponseFut =
        fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#query(&self) -> Self::QueryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<u8>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl_fuchsia_unknown::QueryableQueryResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2658edee9decfc06,
            >(_buf?)?;
            Ok(_response.protocol)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1fd74ee8b9a4a876,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetReuseAddressRequest,
            BaseSocketSetReuseAddressResult,
        >(
            (value,),
            0x1fd74ee8b9a4a876,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetReuseAddressResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x67b7206b8d1bc0a5,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReuseAddressResult>(
                (),
                0x67b7206b8d1bc0a5,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetErrorResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetErrorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_error(&self) -> Self::GetErrorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5aad39b33e5f6ebb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetErrorResult>(
            (),
            0x5aad39b33e5f6ebb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6023e081ce3cd947,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetBroadcastRequest, BaseSocketSetBroadcastResult>(
                (value,),
                0x6023e081ce3cd947,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetBroadcastResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x68796fc556f9780d,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBroadcastResult>(
                (),
                0x68796fc556f9780d,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x756eac32d73a7a70,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetSendBufferRequest, BaseSocketSetSendBufferResult>(
                (value_bytes,),
                0x756eac32d73a7a70,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetSendBufferResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x78a52fd9c7b2410b,
            >(_buf?)?;
            Ok(_response.map(|x| x.value_bytes))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetSendBufferResult>(
                (),
                0x78a52fd9c7b2410b,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6b0cf2f1919c7001,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetReceiveBufferRequest,
            BaseSocketSetReceiveBufferResult,
        >(
            (value_bytes,),
            0x6b0cf2f1919c7001,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetReceiveBufferResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x14c1a4b64f709e5c,
            >(_buf?)?;
            Ok(_response.map(|x| x.value_bytes))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseSocketGetReceiveBufferResult,
        >(
            (),
            0x14c1a4b64f709e5c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x572df8f0b920d2c7,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetKeepAliveRequest, BaseSocketSetKeepAliveResult>(
                (value,),
                0x572df8f0b920d2c7,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetKeepAliveResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2dd29d3215f2c9d2,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetKeepAliveResult>(
                (),
                0x2dd29d3215f2c9d2,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3ecb49968bee439,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetOutOfBandInlineRequest,
            BaseSocketSetOutOfBandInlineResult,
        >(
            (value,),
            0x3ecb49968bee439,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetOutOfBandInlineResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x348c1ab3aeca1745,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseSocketGetOutOfBandInlineResult,
        >(
            (),
            0x348c1ab3aeca1745,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6bbf00c53a4c78c2,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetNoCheckRequest, BaseSocketSetNoCheckResult>(
                (value,),
                0x6bbf00c53a4c78c2,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetNoCheckResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2cd4249286417694,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetNoCheckResult>(
                (),
                0x2cd4249286417694,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetLingerResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x45386351246e998e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<BaseSocketSetLingerRequest, BaseSocketSetLingerResult>(
            (linger, length_secs),
            0x45386351246e998e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetLingerResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_linger(&self) -> Self::GetLingerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetLingerResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x48eb20fc5ccb0e45,
            >(_buf?)?;
            Ok(_response.map(|x| (x.linger, x.length_secs)))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetLingerResult>(
                (),
                0x48eb20fc5ccb0e45,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetReusePortResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x24dd3e5cb36d9ccb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetReusePortRequest, BaseSocketSetReusePortResult>(
                (value,),
                0x24dd3e5cb36d9ccb,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetReusePortResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetReusePortResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7a112c1ab54ff828,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReusePortResult>(
                (),
                0x7a112c1ab54ff828,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetAcceptConnResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetAcceptConnResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x67ce6db6c2ec8966,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetAcceptConnResult>(
                (),
                0x67ce6db6c2ec8966,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2118b483f28aafc4,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetBindToDeviceRequest,
            BaseSocketSetBindToDeviceResult,
        >(
            (value,),
            0x2118b483f28aafc4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetBindToDeviceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ab1fbf0ef7906c8,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBindToDeviceResult>(
                (),
                0x1ab1fbf0ef7906c8,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_bind_to_interface_index(
        &self,
        mut value: u64,
    ) -> Self::SetBindToInterfaceIndexResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6e387a0def00821,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetBindToInterfaceIndexRequest,
            BaseSocketSetBindToInterfaceIndexResult,
        >(
            (value,),
            0x6e387a0def00821,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetBindToInterfaceIndexResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x59c31dd3e3078295,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseSocketGetBindToInterfaceIndexResult,
        >(
            (),
            0x59c31dd3e3078295,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetTimestampResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_timestamp(&self, mut value: TimestampOption) -> Self::SetTimestampResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x285d6516c263d839,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetTimestampRequest, BaseSocketSetTimestampResult>(
                (value,),
                0x285d6516c263d839,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetTimestampResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetTimestampResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x49f2fffbbcc2bd27,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetTimestampResult>(
                (),
                0x49f2fffbbcc2bd27,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetMarkResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        mut mark: &OptionalUint32,
    ) -> Self::SetMarkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6ead6de09f653236,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<BaseSocketSetMarkRequest, BaseSocketSetMarkResult>(
            (domain, mark),
            0x6ead6de09f653236,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetMarkResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x57a2752c61d93d47,
            >(_buf?)?;
            Ok(_response.map(|x| x.mark))
        }
        self.client.send_query_and_decode::<BaseSocketGetMarkRequest, BaseSocketGetMarkResult>(
            (domain,),
            0x57a2752c61d93d47,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetCookieResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetCookieResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_cookie(&self) -> Self::GetCookieResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetCookieResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetCookieResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2c2f47fd8f924e52,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetCookieResult>(
                (),
                0x2c2f47fd8f924e52,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type BindResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketBindResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#bind(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4bc6400ae92125d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseNetworkSocketBindRequest, BaseNetworkSocketBindResult>(
                (addr,),
                0x4bc6400ae92125d,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ConnectResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5f05f19bfdd38871,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketConnectRequest,
            BaseNetworkSocketConnectResult,
        >(
            (addr,),
            0x5f05f19bfdd38871,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DisconnectResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketDisconnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#disconnect(&self) -> Self::DisconnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x74e63b91f7b29b2,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketDisconnectResult,
        >(
            (),
            0x74e63b91f7b29b2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetSockNameResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetSockNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetSockNameResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x475f23f84a1a4f85,
            >(_buf?)?;
            Ok(_response.map(|x| x.addr))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetSockNameResult,
        >(
            (),
            0x475f23f84a1a4f85,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetPeerNameResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetPeerNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetPeerNameResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ffecf4bd5b6432e,
            >(_buf?)?;
            Ok(_response.map(|x| x.addr))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetPeerNameResult,
        >(
            (),
            0x1ffecf4bd5b6432e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ShutdownResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketShutdownResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#shutdown(&self, mut mode: ShutdownMode) -> Self::ShutdownResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x247f38b6db68c336,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketShutdownRequest,
            BaseNetworkSocketShutdownResult,
        >(
            (mode,),
            0x247f38b6db68c336,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_type_of_service(&self, mut value: u8) -> Self::SetIpTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x995c600475b6d46,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpTypeOfServiceRequest,
            BaseNetworkSocketSetIpTypeOfServiceResult,
        >(
            (value,),
            0x995c600475b6d46,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpTypeOfServiceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3814a04259f75fcb,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpTypeOfServiceResult,
        >(
            (),
            0x3814a04259f75fcb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_ttl(&self, mut value: &OptionalUint8) -> Self::SetIpTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x29e2424b433ae1ef,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpTtlRequest,
            BaseNetworkSocketSetIpTtlResult,
        >(
            (value,),
            0x29e2424b433ae1ef,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpTtlResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x47e47fa1f24da471,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseNetworkSocketGetIpTtlResult>(
                (),
                0x47e47fa1f24da471,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_packet_info(&self, mut value: bool) -> Self::SetIpPacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x392d16bee20c0e16,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpPacketInfoRequest,
            BaseNetworkSocketSetIpPacketInfoResult,
        >(
            (value,),
            0x392d16bee20c0e16,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpPacketInfoResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x54b505f242280740,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpPacketInfoResult,
        >(
            (),
            0x54b505f242280740,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_receive_type_of_service(
        &self,
        mut value: bool,
    ) -> Self::SetIpReceiveTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6c4f6714995f84ef,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
            BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
        >(
            (value,),
            0x6c4f6714995f84ef,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4158ba7dc2795960,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
        >(
            (),
            0x4158ba7dc2795960,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_receive_ttl(&self, mut value: bool) -> Self::SetIpReceiveTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x46f15be0ce0ab82b,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpReceiveTtlRequest,
            BaseNetworkSocketSetIpReceiveTtlResult,
        >(
            (value,),
            0x46f15be0ce0ab82b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpReceiveTtlResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x678ddd5a5dfa2eb5,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpReceiveTtlResult,
        >(
            (),
            0x678ddd5a5dfa2eb5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_multicast_interface(
        &self,
        mut iface: u64,
        mut address: &fidl_fuchsia_net::Ipv4Address,
    ) -> Self::SetIpMulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x752fbfa9b12befe,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpMulticastInterfaceRequest,
            BaseNetworkSocketSetIpMulticastInterfaceResult,
        >(
            (iface, address,),
            0x752fbfa9b12befe,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpMulticastInterfaceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x320bd14c4df046c4,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpMulticastInterfaceResult,
        >(
            (),
            0x320bd14c4df046c4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_multicast_ttl(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpMulticastTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x63134d53772916a1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpMulticastTtlRequest,
            BaseNetworkSocketSetIpMulticastTtlResult,
        >(
            (value,),
            0x63134d53772916a1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpMulticastTtlResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4665cd378f39e1a,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpMulticastTtlResult,
        >(
            (),
            0x4665cd378f39e1a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_multicast_loopback(
        &self,
        mut value: bool,
    ) -> Self::SetIpMulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x20c55c11f00943ea,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpMulticastLoopbackRequest,
            BaseNetworkSocketSetIpMulticastLoopbackResult,
        >(
            (value,),
            0x20c55c11f00943ea,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpMulticastLoopbackResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3b6b26ff558298f2,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpMulticastLoopbackResult,
        >(
            (),
            0x3b6b26ff558298f2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddIpMembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> Self::AddIpMembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x76bc7df115a3b4d0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketAddIpMembershipRequest,
            BaseNetworkSocketAddIpMembershipResult,
        >(
            (membership,),
            0x76bc7df115a3b4d0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DropIpMembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#drop_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> Self::DropIpMembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2888f3099188d03,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketDropIpMembershipRequest,
            BaseNetworkSocketDropIpMembershipResult,
        >(
            (membership,),
            0x2888f3099188d03,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpTransparentResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_transparent(&self, mut value: bool) -> Self::SetIpTransparentResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ae532b0c066e3a0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpTransparentRequest,
            BaseNetworkSocketSetIpTransparentResult,
        >(
            (value,),
            0x1ae532b0c066e3a0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpTransparentResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpTransparentResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x51d43695962ebfb5,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpTransparentResult,
        >(
            (),
            0x51d43695962ebfb5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_receive_original_destination_address(
        &self,
        mut value: bool,
    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4722b4ce52f7840,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
        >(
            (value,),
            0x4722b4ce52f7840,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_receive_original_destination_address(
        &self,
    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2a0e7dc5d6bfdfe9,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
        >(
            (),
            0x2a0e7dc5d6bfdfe9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> Self::AddIpv6MembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7c94727acb4ea4b3,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketAddIpv6MembershipRequest,
            BaseNetworkSocketAddIpv6MembershipResult,
        >(
            (membership,),
            0x7c94727acb4ea4b3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DropIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#drop_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> Self::DropIpv6MembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x42104c70ccaba304,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketDropIpv6MembershipRequest,
            BaseNetworkSocketDropIpv6MembershipResult,
        >(
            (membership,),
            0x42104c70ccaba304,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_multicast_interface(
        &self,
        mut value: u64,
    ) -> Self::SetIpv6MulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x135f76db3774ab3b,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
            BaseNetworkSocketSetIpv6MulticastInterfaceResult,
        >(
            (value,),
            0x135f76db3774ab3b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1f26fcdd348f1882,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6MulticastInterfaceResult,
        >(
            (),
            0x1f26fcdd348f1882,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_unicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpv6UnicastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x157d51e98f462859,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6UnicastHopsRequest,
            BaseNetworkSocketSetIpv6UnicastHopsResult,
        >(
            (value,),
            0x157d51e98f462859,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6UnicastHopsResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x21f4641cad8bd8d2,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6UnicastHopsResult,
        >(
            (),
            0x21f4641cad8bd8d2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_receive_hop_limit(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6ReceiveHopLimitResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5c24808ed2e84a1e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
            BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
        >(
            (value,),
            0x5c24808ed2e84a1e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x341e06689885b4c0,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
        >(
            (),
            0x341e06689885b4c0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_multicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpv6MulticastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x25b9cd4d181f82c1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6MulticastHopsRequest,
            BaseNetworkSocketSetIpv6MulticastHopsResult,
        >(
            (value,),
            0x25b9cd4d181f82c1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6MulticastHopsResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x52916948a365012a,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6MulticastHopsResult,
        >(
            (),
            0x52916948a365012a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_multicast_loopback(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6MulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x55701c409ff41b40,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
            BaseNetworkSocketSetIpv6MulticastLoopbackResult,
        >(
            (value,),
            0x55701c409ff41b40,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4415b701fde319c3,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6MulticastLoopbackResult,
        >(
            (),
            0x4415b701fde319c3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_only(&self, mut value: bool) -> Self::SetIpv6OnlyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4873f1364758cbba,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6OnlyRequest,
            BaseNetworkSocketSetIpv6OnlyResult,
        >(
            (value,),
            0x4873f1364758cbba,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6OnlyResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4aa3340a1a26b89c,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6OnlyResult,
        >(
            (),
            0x4aa3340a1a26b89c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_receive_traffic_class(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x58f07c8788d099a0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
            BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
        >(
            (value,),
            0x58f07c8788d099a0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2e334df1da553ffa,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
        >(
            (),
            0x2e334df1da553ffa,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_traffic_class(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpv6TrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6af077800c5a0b4f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6TrafficClassRequest,
            BaseNetworkSocketSetIpv6TrafficClassResult,
        >(
            (value,),
            0x6af077800c5a0b4f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6TrafficClassResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6baf6eed8fc2f04,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6TrafficClassResult,
        >(
            (),
            0x6baf6eed8fc2f04,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_receive_packet_info(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6ReceivePacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x19259775b1a92768,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
            BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
        >(
            (value,),
            0x19259775b1a92768,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7acd4a2775baec75,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
        >(
            (),
            0x7acd4a2775baec75,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetOriginalDestinationResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetOriginalDestinationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetOriginalDestinationResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x38bf28f0dafdbac0,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetOriginalDestinationResult,
        >(
            (),
            0x38bf28f0dafdbac0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DescribeResponseFut = fidl::client::QueryResponseFut<
        StreamSocketDescribeResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#describe(&self) -> Self::DescribeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketDescribeResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                StreamSocketDescribeResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x29e22969a7dadc32,
            >(_buf?)?;
            Ok(_response)
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketDescribeResponse>(
                (),
                0x29e22969a7dadc32,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ListenResponseFut = fidl::client::QueryResponseFut<
        StreamSocketListenResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#listen(&self, mut backlog: i16) -> Self::ListenResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketListenResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3d0a65ced3d10108,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<StreamSocketListenRequest, StreamSocketListenResult>(
            (backlog,),
            0x3d0a65ced3d10108,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AcceptResponseFut = fidl::client::QueryResponseFut<
        StreamSocketAcceptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#accept(&self, mut want_addr: bool) -> Self::AcceptResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketAcceptResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<StreamSocketAcceptResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5ab7ad620424c163,
            >(_buf?)?;
            Ok(_response.map(|x| (x.addr, x.s)))
        }
        self.client.send_query_and_decode::<StreamSocketAcceptRequest, StreamSocketAcceptResult>(
            (want_addr,),
            0x5ab7ad620424c163,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetInfoResponseFut = fidl::client::QueryResponseFut<
        StreamSocketGetInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_info(&self) -> Self::GetInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketGetInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<StreamSocketGetInfoResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x87cfa55d19f878f,
            >(_buf?)?;
            Ok(_response.map(|x| (x.domain, x.proto)))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketGetInfoResult>(
                (),
                0x87cfa55d19f878f,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetTcpNoDelayResponseFut = fidl::client::QueryResponseFut<
        StreamSocketSetTcpNoDelayResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_tcp_no_delay(&self, mut value: bool) -> Self::SetTcpNoDelayResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketSetTcpNoDelayResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5a59b778f7333ada,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            StreamSocketSetTcpNoDelayRequest,
            StreamSocketSetTcpNoDelayResult,
        >(
            (value,),
            0x5a59b778f7333ada,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetTcpNoDelayResponseFut = fidl::client::QueryResponseFut<
        StreamSocketGetTcpNoDelayResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_tcp_no_delay(&self) -> Self::GetTcpNoDelayResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketGetTcpNoDelayResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    StreamSocketGetTcpNoDelayResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xac219a3218b0799,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketGetTcpNoDelayResult>(
                (),
                0xac219a3218b0799,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetTcpMaxSegmentResponseFut = fidl::client::QueryResponseFut<
        StreamSocketSetTcpMaxSegmentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_tcp_max_segment(&self, mut value_bytes: u32) -> Self::SetTcpMaxSegmentResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketSetTcpMaxSegmentResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xb3d30c498266d18,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            StreamSocketSetTcpMaxSegmentRequest,
            StreamSocketSetTcpMaxSegmentResult,
        >(
            (value_bytes,),
            0xb3d30c498266d18,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetTcpMaxSegmentResponseFut = fidl::client::QueryResponseFut<
        StreamSocketGetTcpMaxSegmentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_tcp_max_segment(&self) -> Self::GetTcpMaxSegmentResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketGetTcpMaxSegmentResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    StreamSocketGetTcpMaxSegmentResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x637404d1b4b9982c,
            >(_buf?)?;
            Ok(_response.map(|x| x.value_bytes))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            StreamSocketGetTcpMaxSegmentResult,
        >(
            (),
            0x637404d1b4b9982c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetTcpCorkResponseFut = fidl::client::QueryResponseFut<
        StreamSocketSetTcpCorkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_tcp_cork(&self, mut value: bool) -> Self::SetTcpCorkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketSetTcpCorkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x62e26891541143a0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<StreamSocketSetTcpCorkRequest, StreamSocketSetTcpCorkResult>(
                (value,),
                0x62e26891541143a0,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetTcpCorkResponseFut = fidl::client::QueryResponseFut<
        StreamSocketGetTcpCorkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_tcp_cork(&self) -> Self::GetTcpCorkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketGetTcpCorkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    StreamSocketGetTcpCorkResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x435bb232e0e74f32,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketGetTcpCorkResult>(
                (),
                0x435bb232e0e74f32,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetTcpKeepAliveIdleResponseFut = fidl::client::QueryResponseFut<
        StreamSocketSetTcpKeepAliveIdleResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_tcp_keep_alive_idle(
        &self,
        mut value_secs: u32,
    ) -> Self::SetTcpKeepAliveIdleResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketSetTcpKeepAliveIdleResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x196d053d8363c42,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            StreamSocketSetTcpKeepAliveIdleRequest,
            StreamSocketSetTcpKeepAliveIdleResult,
        >(
            (value_secs,),
            0x196d053d8363c42,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetTcpKeepAliveIdleResponseFut = fidl::client::QueryResponseFut<
        StreamSocketGetTcpKeepAliveIdleResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_tcp_keep_alive_idle(&self) -> Self::GetTcpKeepAliveIdleResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketGetTcpKeepAliveIdleResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    StreamSocketGetTcpKeepAliveIdleResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x35ec58564879dac,
            >(_buf?)?;
            Ok(_response.map(|x| x.value_secs))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            StreamSocketGetTcpKeepAliveIdleResult,
        >(
            (),
            0x35ec58564879dac,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetTcpKeepAliveIntervalResponseFut = fidl::client::QueryResponseFut<
        StreamSocketSetTcpKeepAliveIntervalResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_tcp_keep_alive_interval(
        &self,
        mut value_secs: u32,
    ) -> Self::SetTcpKeepAliveIntervalResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketSetTcpKeepAliveIntervalResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x485ffbc2da1243f2,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            StreamSocketSetTcpKeepAliveIntervalRequest,
            StreamSocketSetTcpKeepAliveIntervalResult,
        >(
            (value_secs,),
            0x485ffbc2da1243f2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetTcpKeepAliveIntervalResponseFut = fidl::client::QueryResponseFut<
        StreamSocketGetTcpKeepAliveIntervalResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_tcp_keep_alive_interval(&self) -> Self::GetTcpKeepAliveIntervalResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketGetTcpKeepAliveIntervalResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    StreamSocketGetTcpKeepAliveIntervalResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x264eaf46306b284,
            >(_buf?)?;
            Ok(_response.map(|x| x.value_secs))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            StreamSocketGetTcpKeepAliveIntervalResult,
        >(
            (),
            0x264eaf46306b284,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetTcpKeepAliveCountResponseFut = fidl::client::QueryResponseFut<
        StreamSocketSetTcpKeepAliveCountResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_tcp_keep_alive_count(&self, mut value: u32) -> Self::SetTcpKeepAliveCountResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketSetTcpKeepAliveCountResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2ab2e8c111708421,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            StreamSocketSetTcpKeepAliveCountRequest,
            StreamSocketSetTcpKeepAliveCountResult,
        >(
            (value,),
            0x2ab2e8c111708421,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetTcpKeepAliveCountResponseFut = fidl::client::QueryResponseFut<
        StreamSocketGetTcpKeepAliveCountResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_tcp_keep_alive_count(&self) -> Self::GetTcpKeepAliveCountResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketGetTcpKeepAliveCountResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    StreamSocketGetTcpKeepAliveCountResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2f176ae271fe7a09,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            StreamSocketGetTcpKeepAliveCountResult,
        >(
            (),
            0x2f176ae271fe7a09,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetTcpSynCountResponseFut = fidl::client::QueryResponseFut<
        StreamSocketSetTcpSynCountResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_tcp_syn_count(&self, mut value: u32) -> Self::SetTcpSynCountResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketSetTcpSynCountResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4dcd6ab5573c1eb3,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            StreamSocketSetTcpSynCountRequest,
            StreamSocketSetTcpSynCountResult,
        >(
            (value,),
            0x4dcd6ab5573c1eb3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetTcpSynCountResponseFut = fidl::client::QueryResponseFut<
        StreamSocketGetTcpSynCountResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_tcp_syn_count(&self) -> Self::GetTcpSynCountResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketGetTcpSynCountResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    StreamSocketGetTcpSynCountResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7d457cba8f5f3ee6,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            StreamSocketGetTcpSynCountResult,
        >(
            (),
            0x7d457cba8f5f3ee6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetTcpLingerResponseFut = fidl::client::QueryResponseFut<
        StreamSocketSetTcpLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_tcp_linger(&self, mut value_secs: &OptionalUint32) -> Self::SetTcpLingerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketSetTcpLingerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xd5cc1e8654d36e4,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            StreamSocketSetTcpLingerRequest,
            StreamSocketSetTcpLingerResult,
        >(
            (value_secs,),
            0xd5cc1e8654d36e4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetTcpLingerResponseFut = fidl::client::QueryResponseFut<
        StreamSocketGetTcpLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_tcp_linger(&self) -> Self::GetTcpLingerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketGetTcpLingerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    StreamSocketGetTcpLingerResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0xad870d311cf30eb,
            >(_buf?)?;
            Ok(_response.map(|x| x.value_secs))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketGetTcpLingerResult>(
                (),
                0xad870d311cf30eb,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetTcpDeferAcceptResponseFut = fidl::client::QueryResponseFut<
        StreamSocketSetTcpDeferAcceptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_tcp_defer_accept(&self, mut value_secs: u32) -> Self::SetTcpDeferAcceptResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketSetTcpDeferAcceptResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x15092f181e57c404,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            StreamSocketSetTcpDeferAcceptRequest,
            StreamSocketSetTcpDeferAcceptResult,
        >(
            (value_secs,),
            0x15092f181e57c404,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetTcpDeferAcceptResponseFut = fidl::client::QueryResponseFut<
        StreamSocketGetTcpDeferAcceptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_tcp_defer_accept(&self) -> Self::GetTcpDeferAcceptResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketGetTcpDeferAcceptResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    StreamSocketGetTcpDeferAcceptResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x64589790842cb7c6,
            >(_buf?)?;
            Ok(_response.map(|x| x.value_secs))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            StreamSocketGetTcpDeferAcceptResult,
        >(
            (),
            0x64589790842cb7c6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetTcpWindowClampResponseFut = fidl::client::QueryResponseFut<
        StreamSocketSetTcpWindowClampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_tcp_window_clamp(&self, mut value: u32) -> Self::SetTcpWindowClampResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketSetTcpWindowClampResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4a26ce07d847f1c6,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            StreamSocketSetTcpWindowClampRequest,
            StreamSocketSetTcpWindowClampResult,
        >(
            (value,),
            0x4a26ce07d847f1c6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetTcpWindowClampResponseFut = fidl::client::QueryResponseFut<
        StreamSocketGetTcpWindowClampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_tcp_window_clamp(&self) -> Self::GetTcpWindowClampResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketGetTcpWindowClampResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    StreamSocketGetTcpWindowClampResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2df6b636bf0a6a4e,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            StreamSocketGetTcpWindowClampResult,
        >(
            (),
            0x2df6b636bf0a6a4e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetTcpInfoResponseFut = fidl::client::QueryResponseFut<
        StreamSocketGetTcpInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_tcp_info(&self) -> Self::GetTcpInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketGetTcpInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    StreamSocketGetTcpInfoResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ffb123d9f03ead2,
            >(_buf?)?;
            Ok(_response.map(|x| x.info))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketGetTcpInfoResult>(
                (),
                0x1ffb123d9f03ead2,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetTcpQuickAckResponseFut = fidl::client::QueryResponseFut<
        StreamSocketSetTcpQuickAckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_tcp_quick_ack(&self, mut value: bool) -> Self::SetTcpQuickAckResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketSetTcpQuickAckResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6fa811be8fde7457,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            StreamSocketSetTcpQuickAckRequest,
            StreamSocketSetTcpQuickAckResult,
        >(
            (value,),
            0x6fa811be8fde7457,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetTcpQuickAckResponseFut = fidl::client::QueryResponseFut<
        StreamSocketGetTcpQuickAckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_tcp_quick_ack(&self) -> Self::GetTcpQuickAckResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketGetTcpQuickAckResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    StreamSocketGetTcpQuickAckResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7356a949bef2df32,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            StreamSocketGetTcpQuickAckResult,
        >(
            (),
            0x7356a949bef2df32,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetTcpCongestionResponseFut = fidl::client::QueryResponseFut<
        StreamSocketSetTcpCongestionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_tcp_congestion(
        &self,
        mut value: TcpCongestionControl,
    ) -> Self::SetTcpCongestionResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketSetTcpCongestionResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7924c6eabde7819e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            StreamSocketSetTcpCongestionRequest,
            StreamSocketSetTcpCongestionResult,
        >(
            (value,),
            0x7924c6eabde7819e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetTcpCongestionResponseFut = fidl::client::QueryResponseFut<
        StreamSocketGetTcpCongestionResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_tcp_congestion(&self) -> Self::GetTcpCongestionResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketGetTcpCongestionResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    StreamSocketGetTcpCongestionResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x11e16397e1b72a47,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            StreamSocketGetTcpCongestionResult,
        >(
            (),
            0x11e16397e1b72a47,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetTcpUserTimeoutResponseFut = fidl::client::QueryResponseFut<
        StreamSocketSetTcpUserTimeoutResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_tcp_user_timeout(&self, mut value_millis: u32) -> Self::SetTcpUserTimeoutResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketSetTcpUserTimeoutResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6b459e81c3741a60,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            StreamSocketSetTcpUserTimeoutRequest,
            StreamSocketSetTcpUserTimeoutResult,
        >(
            (value_millis,),
            0x6b459e81c3741a60,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetTcpUserTimeoutResponseFut = fidl::client::QueryResponseFut<
        StreamSocketGetTcpUserTimeoutResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_tcp_user_timeout(&self) -> Self::GetTcpUserTimeoutResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<StreamSocketGetTcpUserTimeoutResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    StreamSocketGetTcpUserTimeoutResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x24bbd5858ad8c380,
            >(_buf?)?;
            Ok(_response.map(|x| x.value_millis))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            StreamSocketGetTcpUserTimeoutResult,
        >(
            (),
            0x24bbd5858ad8c380,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct StreamSocketEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for StreamSocketEventStream {}

impl futures::stream::FusedStream for StreamSocketEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for StreamSocketEventStream {
    type Item = Result<StreamSocketEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(StreamSocketEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum StreamSocketEvent {}

impl StreamSocketEvent {
    /// Decodes a message buffer as a [`StreamSocketEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<StreamSocketEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <StreamSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.posix.socket/StreamSocket.
pub struct StreamSocketRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for StreamSocketRequestStream {}

impl futures::stream::FusedStream for StreamSocketRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for StreamSocketRequestStream {
    type Protocol = StreamSocketMarker;
    type ControlHandle = StreamSocketControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        StreamSocketControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for StreamSocketRequestStream {
    type Item = Result<StreamSocketRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled StreamSocketRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x20d8a7aba2168a79 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl_fuchsia_unknown::CloneableCloneRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::Clone { request: req.request, control_handle })
                    }
                    0x5ac5d459ad7f657e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::Close {
                            responder: StreamSocketCloseResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2658edee9decfc06 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::Query {
                            responder: StreamSocketQueryResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1fd74ee8b9a4a876 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetReuseAddressRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetReuseAddress {
                            value: req.value,

                            responder: StreamSocketSetReuseAddressResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x67b7206b8d1bc0a5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetReuseAddress {
                            responder: StreamSocketGetReuseAddressResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5aad39b33e5f6ebb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetError {
                            responder: StreamSocketGetErrorResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6023e081ce3cd947 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetBroadcastRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetBroadcast {
                            value: req.value,

                            responder: StreamSocketSetBroadcastResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x68796fc556f9780d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetBroadcast {
                            responder: StreamSocketGetBroadcastResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x756eac32d73a7a70 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetSendBufferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetSendBuffer {
                            value_bytes: req.value_bytes,

                            responder: StreamSocketSetSendBufferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x78a52fd9c7b2410b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetSendBuffer {
                            responder: StreamSocketGetSendBufferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6b0cf2f1919c7001 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetReceiveBufferRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetReceiveBuffer {
                            value_bytes: req.value_bytes,

                            responder: StreamSocketSetReceiveBufferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x14c1a4b64f709e5c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetReceiveBuffer {
                            responder: StreamSocketGetReceiveBufferResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x572df8f0b920d2c7 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetKeepAliveRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetKeepAlive {
                            value: req.value,

                            responder: StreamSocketSetKeepAliveResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2dd29d3215f2c9d2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetKeepAlive {
                            responder: StreamSocketGetKeepAliveResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3ecb49968bee439 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetOutOfBandInlineRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetOutOfBandInline {
                            value: req.value,

                            responder: StreamSocketSetOutOfBandInlineResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x348c1ab3aeca1745 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetOutOfBandInline {
                            responder: StreamSocketGetOutOfBandInlineResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6bbf00c53a4c78c2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetNoCheckRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetNoCheck {
                            value: req.value,

                            responder: StreamSocketSetNoCheckResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2cd4249286417694 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetNoCheck {
                            responder: StreamSocketGetNoCheckResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x45386351246e998e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetLingerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetLinger {
                            linger: req.linger,
                            length_secs: req.length_secs,

                            responder: StreamSocketSetLingerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x48eb20fc5ccb0e45 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetLinger {
                            responder: StreamSocketGetLingerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x24dd3e5cb36d9ccb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetReusePortRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetReusePort {
                            value: req.value,

                            responder: StreamSocketSetReusePortResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7a112c1ab54ff828 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetReusePort {
                            responder: StreamSocketGetReusePortResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x67ce6db6c2ec8966 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetAcceptConn {
                            responder: StreamSocketGetAcceptConnResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2118b483f28aafc4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetBindToDeviceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetBindToDevice {
                            value: req.value,

                            responder: StreamSocketSetBindToDeviceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1ab1fbf0ef7906c8 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetBindToDevice {
                            responder: StreamSocketGetBindToDeviceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6e387a0def00821 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetBindToInterfaceIndexRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetBindToInterfaceIndex {
                            value: req.value,

                            responder: StreamSocketSetBindToInterfaceIndexResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x59c31dd3e3078295 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetBindToInterfaceIndex {
                            responder: StreamSocketGetBindToInterfaceIndexResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x285d6516c263d839 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetTimestampRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetTimestamp {
                            value: req.value,

                            responder: StreamSocketSetTimestampResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x49f2fffbbcc2bd27 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetTimestamp {
                            responder: StreamSocketGetTimestampResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6ead6de09f653236 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketSetMarkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetMark {
                            domain: req.domain,
                            mark: req.mark,

                            responder: StreamSocketSetMarkResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x57a2752c61d93d47 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseSocketGetMarkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetMark {
                            domain: req.domain,

                            responder: StreamSocketGetMarkResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2c2f47fd8f924e52 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetCookie {
                            responder: StreamSocketGetCookieResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4bc6400ae92125d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketBindRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketBindRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::Bind {
                            addr: req.addr,

                            responder: StreamSocketBindResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5f05f19bfdd38871 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketConnectRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::Connect {
                            addr: req.addr,

                            responder: StreamSocketConnectResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x74e63b91f7b29b2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::Disconnect {
                            responder: StreamSocketDisconnectResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x475f23f84a1a4f85 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetSockName {
                            responder: StreamSocketGetSockNameResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1ffecf4bd5b6432e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetPeerName {
                            responder: StreamSocketGetPeerNameResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x247f38b6db68c336 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketShutdownRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketShutdownRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::Shutdown {
                            mode: req.mode,

                            responder: StreamSocketShutdownResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x995c600475b6d46 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpTypeOfServiceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpTypeOfService {
                            value: req.value,

                            responder: StreamSocketSetIpTypeOfServiceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3814a04259f75fcb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpTypeOfService {
                            responder: StreamSocketGetIpTypeOfServiceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x29e2424b433ae1ef => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpTtlRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTtlRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpTtl {
                            value: req.value,

                            responder: StreamSocketSetIpTtlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x47e47fa1f24da471 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpTtl {
                            responder: StreamSocketGetIpTtlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x392d16bee20c0e16 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpPacketInfoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpPacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpPacketInfo {
                            value: req.value,

                            responder: StreamSocketSetIpPacketInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x54b505f242280740 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpPacketInfo {
                            responder: StreamSocketGetIpPacketInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6c4f6714995f84ef => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpReceiveTypeOfService {
                            value: req.value,

                            responder: StreamSocketSetIpReceiveTypeOfServiceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4158ba7dc2795960 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpReceiveTypeOfService {
                            responder: StreamSocketGetIpReceiveTypeOfServiceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x46f15be0ce0ab82b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpReceiveTtlRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTtlRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpReceiveTtl {
                            value: req.value,

                            responder: StreamSocketSetIpReceiveTtlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x678ddd5a5dfa2eb5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpReceiveTtl {
                            responder: StreamSocketGetIpReceiveTtlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x752fbfa9b12befe => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpMulticastInterfaceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpMulticastInterface {
                            iface: req.iface,
                            address: req.address,

                            responder: StreamSocketSetIpMulticastInterfaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x320bd14c4df046c4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpMulticastInterface {
                            responder: StreamSocketGetIpMulticastInterfaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x63134d53772916a1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpMulticastTtlRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastTtlRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpMulticastTtl {
                            value: req.value,

                            responder: StreamSocketSetIpMulticastTtlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4665cd378f39e1a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpMulticastTtl {
                            responder: StreamSocketGetIpMulticastTtlResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x20c55c11f00943ea => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpMulticastLoopbackRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpMulticastLoopback {
                            value: req.value,

                            responder: StreamSocketSetIpMulticastLoopbackResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3b6b26ff558298f2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpMulticastLoopback {
                            responder: StreamSocketGetIpMulticastLoopbackResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x76bc7df115a3b4d0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketAddIpMembershipRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::AddIpMembership {
                            membership: req.membership,

                            responder: StreamSocketAddIpMembershipResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2888f3099188d03 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketDropIpMembershipRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::DropIpMembership {
                            membership: req.membership,

                            responder: StreamSocketDropIpMembershipResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1ae532b0c066e3a0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpTransparentRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTransparentRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpTransparent {
                            value: req.value,

                            responder: StreamSocketSetIpTransparentResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x51d43695962ebfb5 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpTransparent {
                            responder: StreamSocketGetIpTransparentResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4722b4ce52f7840 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpReceiveOriginalDestinationAddress {
                            value: req.value,

                            responder:
                                StreamSocketSetIpReceiveOriginalDestinationAddressResponder {
                                    control_handle: std::mem::ManuallyDrop::new(control_handle),
                                    tx_id: header.tx_id,
                                },
                        })
                    }
                    0x2a0e7dc5d6bfdfe9 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpReceiveOriginalDestinationAddress {
                            responder:
                                StreamSocketGetIpReceiveOriginalDestinationAddressResponder {
                                    control_handle: std::mem::ManuallyDrop::new(control_handle),
                                    tx_id: header.tx_id,
                                },
                        })
                    }
                    0x7c94727acb4ea4b3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketAddIpv6MembershipRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::AddIpv6Membership {
                            membership: req.membership,

                            responder: StreamSocketAddIpv6MembershipResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x42104c70ccaba304 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketDropIpv6MembershipRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::DropIpv6Membership {
                            membership: req.membership,

                            responder: StreamSocketDropIpv6MembershipResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x135f76db3774ab3b => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpv6MulticastInterface {
                            value: req.value,

                            responder: StreamSocketSetIpv6MulticastInterfaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1f26fcdd348f1882 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpv6MulticastInterface {
                            responder: StreamSocketGetIpv6MulticastInterfaceResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x157d51e98f462859 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6UnicastHopsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6UnicastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpv6UnicastHops {
                            value: req.value,

                            responder: StreamSocketSetIpv6UnicastHopsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x21f4641cad8bd8d2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpv6UnicastHops {
                            responder: StreamSocketGetIpv6UnicastHopsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5c24808ed2e84a1e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveHopLimitRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpv6ReceiveHopLimit {
                            value: req.value,

                            responder: StreamSocketSetIpv6ReceiveHopLimitResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x341e06689885b4c0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpv6ReceiveHopLimit {
                            responder: StreamSocketGetIpv6ReceiveHopLimitResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x25b9cd4d181f82c1 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6MulticastHopsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpv6MulticastHops {
                            value: req.value,

                            responder: StreamSocketSetIpv6MulticastHopsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x52916948a365012a => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpv6MulticastHops {
                            responder: StreamSocketGetIpv6MulticastHopsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x55701c409ff41b40 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpv6MulticastLoopback {
                            value: req.value,

                            responder: StreamSocketSetIpv6MulticastLoopbackResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4415b701fde319c3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpv6MulticastLoopback {
                            responder: StreamSocketGetIpv6MulticastLoopbackResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4873f1364758cbba => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6OnlyRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6OnlyRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpv6Only {
                            value: req.value,

                            responder: StreamSocketSetIpv6OnlyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4aa3340a1a26b89c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpv6Only {
                            responder: StreamSocketGetIpv6OnlyResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x58f07c8788d099a0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpv6ReceiveTrafficClass {
                            value: req.value,

                            responder: StreamSocketSetIpv6ReceiveTrafficClassResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2e334df1da553ffa => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpv6ReceiveTrafficClass {
                            responder: StreamSocketGetIpv6ReceiveTrafficClassResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6af077800c5a0b4f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6TrafficClassRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6TrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpv6TrafficClass {
                            value: req.value,

                            responder: StreamSocketSetIpv6TrafficClassResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6baf6eed8fc2f04 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpv6TrafficClass {
                            responder: StreamSocketGetIpv6TrafficClassResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x19259775b1a92768 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceivePacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetIpv6ReceivePacketInfo {
                            value: req.value,

                            responder: StreamSocketSetIpv6ReceivePacketInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7acd4a2775baec75 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetIpv6ReceivePacketInfo {
                            responder: StreamSocketGetIpv6ReceivePacketInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x38bf28f0dafdbac0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetOriginalDestination {
                            responder: StreamSocketGetOriginalDestinationResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x29e22969a7dadc32 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::Describe {
                            responder: StreamSocketDescribeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x3d0a65ced3d10108 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketListenRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketListenRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::Listen {
                            backlog: req.backlog,

                            responder: StreamSocketListenResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5ab7ad620424c163 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketAcceptRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketAcceptRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::Accept {
                            want_addr: req.want_addr,

                            responder: StreamSocketAcceptResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x87cfa55d19f878f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetInfo {
                            responder: StreamSocketGetInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x5a59b778f7333ada => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketSetTcpNoDelayRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpNoDelayRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetTcpNoDelay {
                            value: req.value,

                            responder: StreamSocketSetTcpNoDelayResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xac219a3218b0799 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetTcpNoDelay {
                            responder: StreamSocketGetTcpNoDelayResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xb3d30c498266d18 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketSetTcpMaxSegmentRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpMaxSegmentRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetTcpMaxSegment {
                            value_bytes: req.value_bytes,

                            responder: StreamSocketSetTcpMaxSegmentResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x637404d1b4b9982c => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetTcpMaxSegment {
                            responder: StreamSocketGetTcpMaxSegmentResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x62e26891541143a0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketSetTcpCorkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpCorkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetTcpCork {
                            value: req.value,

                            responder: StreamSocketSetTcpCorkResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x435bb232e0e74f32 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetTcpCork {
                            responder: StreamSocketGetTcpCorkResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x196d053d8363c42 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketSetTcpKeepAliveIdleRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpKeepAliveIdleRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetTcpKeepAliveIdle {
                            value_secs: req.value_secs,

                            responder: StreamSocketSetTcpKeepAliveIdleResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x35ec58564879dac => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetTcpKeepAliveIdle {
                            responder: StreamSocketGetTcpKeepAliveIdleResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x485ffbc2da1243f2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketSetTcpKeepAliveIntervalRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpKeepAliveIntervalRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetTcpKeepAliveInterval {
                            value_secs: req.value_secs,

                            responder: StreamSocketSetTcpKeepAliveIntervalResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x264eaf46306b284 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetTcpKeepAliveInterval {
                            responder: StreamSocketGetTcpKeepAliveIntervalResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2ab2e8c111708421 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketSetTcpKeepAliveCountRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpKeepAliveCountRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetTcpKeepAliveCount {
                            value: req.value,

                            responder: StreamSocketSetTcpKeepAliveCountResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2f176ae271fe7a09 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetTcpKeepAliveCount {
                            responder: StreamSocketGetTcpKeepAliveCountResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4dcd6ab5573c1eb3 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketSetTcpSynCountRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpSynCountRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetTcpSynCount {
                            value: req.value,

                            responder: StreamSocketSetTcpSynCountResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7d457cba8f5f3ee6 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetTcpSynCount {
                            responder: StreamSocketGetTcpSynCountResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xd5cc1e8654d36e4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketSetTcpLingerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpLingerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetTcpLinger {
                            value_secs: req.value_secs,

                            responder: StreamSocketSetTcpLingerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0xad870d311cf30eb => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetTcpLinger {
                            responder: StreamSocketGetTcpLingerResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x15092f181e57c404 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketSetTcpDeferAcceptRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpDeferAcceptRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetTcpDeferAccept {
                            value_secs: req.value_secs,

                            responder: StreamSocketSetTcpDeferAcceptResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x64589790842cb7c6 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetTcpDeferAccept {
                            responder: StreamSocketGetTcpDeferAcceptResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x4a26ce07d847f1c6 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketSetTcpWindowClampRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpWindowClampRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetTcpWindowClamp {
                            value: req.value,

                            responder: StreamSocketSetTcpWindowClampResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x2df6b636bf0a6a4e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetTcpWindowClamp {
                            responder: StreamSocketGetTcpWindowClampResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x1ffb123d9f03ead2 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetTcpInfo {
                            responder: StreamSocketGetTcpInfoResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6fa811be8fde7457 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketSetTcpQuickAckRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpQuickAckRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetTcpQuickAck {
                            value: req.value,

                            responder: StreamSocketSetTcpQuickAckResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7356a949bef2df32 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetTcpQuickAck {
                            responder: StreamSocketGetTcpQuickAckResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7924c6eabde7819e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketSetTcpCongestionRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpCongestionRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetTcpCongestion {
                            value: req.value,

                            responder: StreamSocketSetTcpCongestionResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x11e16397e1b72a47 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetTcpCongestion {
                            responder: StreamSocketGetTcpCongestionResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6b459e81c3741a60 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            StreamSocketSetTcpUserTimeoutRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpUserTimeoutRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::SetTcpUserTimeout {
                            value_millis: req.value_millis,

                            responder: StreamSocketSetTcpUserTimeoutResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x24bbd5858ad8c380 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            StreamSocketControlHandle { inner: this.inner.clone() };
                        Ok(StreamSocketRequest::GetTcpUserTimeout {
                            responder: StreamSocketGetTcpUserTimeoutResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <StreamSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// A stream socket.
///
/// All methods on this type are nonblocking; their exact behaviors match their
/// Linux counterparts.
///
/// *Warning:* This protocol is not yet ready for direct use by clients.
/// Instead, clients should use the BSD sockets API to interact with sockets.
/// We plan to change this protocol substantially and clients that couple
/// directly to this protocol will make those changes more difficult.
#[derive(Debug)]
pub enum StreamSocketRequest {
    Clone {
        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
        control_handle: StreamSocketControlHandle,
    },
    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    Close {
        responder: StreamSocketCloseResponder,
    },
    Query {
        responder: StreamSocketQueryResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
    SetReuseAddress {
        value: bool,
        responder: StreamSocketSetReuseAddressResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
    GetReuseAddress {
        responder: StreamSocketGetReuseAddressResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_ERROR`.
    /// Returns the last error if there is an error set on the socket.
    GetError {
        responder: StreamSocketGetErrorResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
    SetBroadcast {
        value: bool,
        responder: StreamSocketSetBroadcastResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
    GetBroadcast {
        responder: StreamSocketGetBroadcastResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
    SetSendBuffer {
        value_bytes: u64,
        responder: StreamSocketSetSendBufferResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
    GetSendBuffer {
        responder: StreamSocketGetSendBufferResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
    SetReceiveBuffer {
        value_bytes: u64,
        responder: StreamSocketSetReceiveBufferResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
    GetReceiveBuffer {
        responder: StreamSocketGetReceiveBufferResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
    SetKeepAlive {
        value: bool,
        responder: StreamSocketSetKeepAliveResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
    GetKeepAlive {
        responder: StreamSocketGetKeepAliveResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
    SetOutOfBandInline {
        value: bool,
        responder: StreamSocketSetOutOfBandInlineResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
    GetOutOfBandInline {
        responder: StreamSocketGetOutOfBandInlineResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
    SetNoCheck {
        value: bool,
        responder: StreamSocketSetNoCheckResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
    GetNoCheck {
        responder: StreamSocketGetNoCheckResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_LINGER`.
    SetLinger {
        linger: bool,
        length_secs: u32,
        responder: StreamSocketSetLingerResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_LINGER`.
    GetLinger {
        responder: StreamSocketGetLingerResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
    SetReusePort {
        value: bool,
        responder: StreamSocketSetReusePortResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
    GetReusePort {
        responder: StreamSocketGetReusePortResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
    GetAcceptConn {
        responder: StreamSocketGetAcceptConnResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    SetBindToDevice {
        value: String,
        responder: StreamSocketSetBindToDeviceResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    GetBindToDevice {
        responder: StreamSocketGetBindToDeviceResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    /// If `value` is 0, this clears the bound interface.
    SetBindToInterfaceIndex {
        value: u64,
        responder: StreamSocketSetBindToInterfaceIndexResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    GetBindToInterfaceIndex {
        responder: StreamSocketGetBindToInterfaceIndexResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    SetTimestamp {
        value: TimestampOption,
        responder: StreamSocketSetTimestampResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    GetTimestamp {
        responder: StreamSocketGetTimestampResponder,
    },
    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be set independently in each domain.
    SetMark {
        domain: fidl_fuchsia_net::MarkDomain,
        mark: OptionalUint32,
        responder: StreamSocketSetMarkResponder,
    },
    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be retrieved independently in each domain.
    GetMark {
        domain: fidl_fuchsia_net::MarkDomain,
        responder: StreamSocketGetMarkResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
    GetCookie {
        responder: StreamSocketGetCookieResponder,
    },
    /// Sets the local address used for the socket.
    Bind {
        addr: fidl_fuchsia_net::SocketAddress,
        responder: StreamSocketBindResponder,
    },
    /// Initiates a connection to a remote address.
    Connect {
        addr: fidl_fuchsia_net::SocketAddress,
        responder: StreamSocketConnectResponder,
    },
    /// Clears connection information from this socket.
    Disconnect {
        responder: StreamSocketDisconnectResponder,
    },
    /// Retrieves the local socket address.
    GetSockName {
        responder: StreamSocketGetSockNameResponder,
    },
    /// Retrieves the remote socket address.
    GetPeerName {
        responder: StreamSocketGetPeerNameResponder,
    },
    /// Shuts down part of the socket.
    Shutdown {
        mode: ShutdownMode,
        responder: StreamSocketShutdownResponder,
    },
    /// Set `SOL_IP` -> `IP_TOS`.
    SetIpTypeOfService {
        value: u8,
        responder: StreamSocketSetIpTypeOfServiceResponder,
    },
    /// Get `SOL_IP` -> `IP_TOS`.
    GetIpTypeOfService {
        responder: StreamSocketGetIpTypeOfServiceResponder,
    },
    /// Set `SOL_IP` -> `IP_TTL`.
    SetIpTtl {
        value: OptionalUint8,
        responder: StreamSocketSetIpTtlResponder,
    },
    /// Get `SOL_IP` -> `IP_TTL`.
    GetIpTtl {
        responder: StreamSocketGetIpTtlResponder,
    },
    /// Set `SOL_IP` -> `IP_PKTINFO`.
    SetIpPacketInfo {
        value: bool,
        responder: StreamSocketSetIpPacketInfoResponder,
    },
    /// Get `SOL_IP` -> `IP_PKTINFO`.
    GetIpPacketInfo {
        responder: StreamSocketGetIpPacketInfoResponder,
    },
    /// Set `SOL_IP` -> `IP_RECVTOS`.
    SetIpReceiveTypeOfService {
        value: bool,
        responder: StreamSocketSetIpReceiveTypeOfServiceResponder,
    },
    /// Get `SOL_IP` -> `IP_RECVTOS`.
    GetIpReceiveTypeOfService {
        responder: StreamSocketGetIpReceiveTypeOfServiceResponder,
    },
    /// Set `SOL_IP` -> `IP_RECVTTL`.
    SetIpReceiveTtl {
        value: bool,
        responder: StreamSocketSetIpReceiveTtlResponder,
    },
    /// Get `SOL_IP` -> `IP_RECVTTL`.
    GetIpReceiveTtl {
        responder: StreamSocketGetIpReceiveTtlResponder,
    },
    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
    SetIpMulticastInterface {
        iface: u64,
        address: fidl_fuchsia_net::Ipv4Address,
        responder: StreamSocketSetIpMulticastInterfaceResponder,
    },
    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
    GetIpMulticastInterface {
        responder: StreamSocketGetIpMulticastInterfaceResponder,
    },
    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
    SetIpMulticastTtl {
        value: OptionalUint8,
        responder: StreamSocketSetIpMulticastTtlResponder,
    },
    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
    GetIpMulticastTtl {
        responder: StreamSocketGetIpMulticastTtlResponder,
    },
    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
    SetIpMulticastLoopback {
        value: bool,
        responder: StreamSocketSetIpMulticastLoopbackResponder,
    },
    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
    GetIpMulticastLoopback {
        responder: StreamSocketGetIpMulticastLoopbackResponder,
    },
    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
    AddIpMembership {
        membership: IpMulticastMembership,
        responder: StreamSocketAddIpMembershipResponder,
    },
    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
    DropIpMembership {
        membership: IpMulticastMembership,
        responder: StreamSocketDropIpMembershipResponder,
    },
    /// Set `SOL_IP` -> `IP_TRANSPARENT`
    SetIpTransparent {
        value: bool,
        responder: StreamSocketSetIpTransparentResponder,
    },
    /// Get `SOL_IP` -> `IP_TRANSPARENT`
    GetIpTransparent {
        responder: StreamSocketGetIpTransparentResponder,
    },
    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
    SetIpReceiveOriginalDestinationAddress {
        value: bool,
        responder: StreamSocketSetIpReceiveOriginalDestinationAddressResponder,
    },
    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
    GetIpReceiveOriginalDestinationAddress {
        responder: StreamSocketGetIpReceiveOriginalDestinationAddressResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
    AddIpv6Membership {
        membership: Ipv6MulticastMembership,
        responder: StreamSocketAddIpv6MembershipResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
    DropIpv6Membership {
        membership: Ipv6MulticastMembership,
        responder: StreamSocketDropIpv6MembershipResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    SetIpv6MulticastInterface {
        value: u64,
        responder: StreamSocketSetIpv6MulticastInterfaceResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    GetIpv6MulticastInterface {
        responder: StreamSocketGetIpv6MulticastInterfaceResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    SetIpv6UnicastHops {
        value: OptionalUint8,
        responder: StreamSocketSetIpv6UnicastHopsResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    GetIpv6UnicastHops {
        responder: StreamSocketGetIpv6UnicastHopsResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    SetIpv6ReceiveHopLimit {
        value: bool,
        responder: StreamSocketSetIpv6ReceiveHopLimitResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    GetIpv6ReceiveHopLimit {
        responder: StreamSocketGetIpv6ReceiveHopLimitResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    SetIpv6MulticastHops {
        value: OptionalUint8,
        responder: StreamSocketSetIpv6MulticastHopsResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    GetIpv6MulticastHops {
        responder: StreamSocketGetIpv6MulticastHopsResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    SetIpv6MulticastLoopback {
        value: bool,
        responder: StreamSocketSetIpv6MulticastLoopbackResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    GetIpv6MulticastLoopback {
        responder: StreamSocketGetIpv6MulticastLoopbackResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
    SetIpv6Only {
        value: bool,
        responder: StreamSocketSetIpv6OnlyResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
    GetIpv6Only {
        responder: StreamSocketGetIpv6OnlyResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    SetIpv6ReceiveTrafficClass {
        value: bool,
        responder: StreamSocketSetIpv6ReceiveTrafficClassResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    GetIpv6ReceiveTrafficClass {
        responder: StreamSocketGetIpv6ReceiveTrafficClassResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
    SetIpv6TrafficClass {
        value: OptionalUint8,
        responder: StreamSocketSetIpv6TrafficClassResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
    GetIpv6TrafficClass {
        responder: StreamSocketGetIpv6TrafficClassResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    SetIpv6ReceivePacketInfo {
        value: bool,
        responder: StreamSocketSetIpv6ReceivePacketInfoResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    GetIpv6ReceivePacketInfo {
        responder: StreamSocketGetIpv6ReceivePacketInfoResponder,
    },
    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
    GetOriginalDestination {
        responder: StreamSocketGetOriginalDestinationResponder,
    },
    Describe {
        responder: StreamSocketDescribeResponder,
    },
    /// Begins listening for new incoming connections. At most `backlog`
    /// connections will be buffered.
    Listen {
        backlog: i16,
        responder: StreamSocketListenResponder,
    },
    /// Accepts a buffered incoming connection.
    Accept {
        want_addr: bool,
        responder: StreamSocketAcceptResponder,
    },
    /// Retrieves creation information from the socket.
    GetInfo {
        responder: StreamSocketGetInfoResponder,
    },
    /// Set `SOL_TCP` -> `TCP_NODELAY`.
    SetTcpNoDelay {
        value: bool,
        responder: StreamSocketSetTcpNoDelayResponder,
    },
    /// Get `SOL_TCP` -> `TCP_NODELAY`.
    GetTcpNoDelay {
        responder: StreamSocketGetTcpNoDelayResponder,
    },
    /// Set `SOL_TCP` -> `TCP_MAXSEG`.
    SetTcpMaxSegment {
        value_bytes: u32,
        responder: StreamSocketSetTcpMaxSegmentResponder,
    },
    /// Get `SOL_TCP` -> `TCP_MAXSEG`.
    GetTcpMaxSegment {
        responder: StreamSocketGetTcpMaxSegmentResponder,
    },
    /// Set `SOL_TCP` -> `TCP_CORK`.
    SetTcpCork {
        value: bool,
        responder: StreamSocketSetTcpCorkResponder,
    },
    /// Get `SOL_TCP` -> `TCP_CORK`.
    GetTcpCork {
        responder: StreamSocketGetTcpCorkResponder,
    },
    /// Set `SOL_TCP` -> `TCP_KEEPIDLE`.
    SetTcpKeepAliveIdle {
        value_secs: u32,
        responder: StreamSocketSetTcpKeepAliveIdleResponder,
    },
    /// Get `SOL_TCP` -> `TCP_KEEPIDLE`.
    GetTcpKeepAliveIdle {
        responder: StreamSocketGetTcpKeepAliveIdleResponder,
    },
    /// Set `SOL_TCP` -> `TCP_KEEPINTVL`.
    SetTcpKeepAliveInterval {
        value_secs: u32,
        responder: StreamSocketSetTcpKeepAliveIntervalResponder,
    },
    /// Get `SOL_TCP` -> `TCP_KEEPINTVL`.
    GetTcpKeepAliveInterval {
        responder: StreamSocketGetTcpKeepAliveIntervalResponder,
    },
    /// Set `SOL_TCP` -> `TCP_KEEPCNT`.
    SetTcpKeepAliveCount {
        value: u32,
        responder: StreamSocketSetTcpKeepAliveCountResponder,
    },
    /// Get `SOL_TCP` -> `TCP_KEEPCNT`.
    GetTcpKeepAliveCount {
        responder: StreamSocketGetTcpKeepAliveCountResponder,
    },
    /// Set `SOL_TCP` -> `TCP_SYNCNT`.
    SetTcpSynCount {
        value: u32,
        responder: StreamSocketSetTcpSynCountResponder,
    },
    /// Get `SOL_TCP` -> `TCP_SYNCNT`.
    GetTcpSynCount {
        responder: StreamSocketGetTcpSynCountResponder,
    },
    /// Set `SOL_TCP` -> `TCP_LINGER2`.
    SetTcpLinger {
        value_secs: OptionalUint32,
        responder: StreamSocketSetTcpLingerResponder,
    },
    /// Get `SOL_TCP` -> `TCP_LINGER2`.
    GetTcpLinger {
        responder: StreamSocketGetTcpLingerResponder,
    },
    /// Set `SOL_TCP` -> `TCP_DEFER_ACCEPT`.
    SetTcpDeferAccept {
        value_secs: u32,
        responder: StreamSocketSetTcpDeferAcceptResponder,
    },
    /// Get `SOL_TCP` -> `TCP_DEFER_ACCEPT`.
    GetTcpDeferAccept {
        responder: StreamSocketGetTcpDeferAcceptResponder,
    },
    /// Set `SOL_TCP` -> `TCP_WINDOW_CLAMP`.
    SetTcpWindowClamp {
        value: u32,
        responder: StreamSocketSetTcpWindowClampResponder,
    },
    /// Get `SOL_TCP` -> `TCP_WINDOW_CLAMP`.
    GetTcpWindowClamp {
        responder: StreamSocketGetTcpWindowClampResponder,
    },
    /// Get `SOL_TCP` -> `TCP_INFO`.
    GetTcpInfo {
        responder: StreamSocketGetTcpInfoResponder,
    },
    /// Set `SOL_TCP` -> `TCP_QUICKACK`.
    SetTcpQuickAck {
        value: bool,
        responder: StreamSocketSetTcpQuickAckResponder,
    },
    /// Get `SOL_TCP` -> `TCP_QUICKACK`.
    GetTcpQuickAck {
        responder: StreamSocketGetTcpQuickAckResponder,
    },
    /// Set `SOL_TCP` -> `TCP_CONGESTION`.
    SetTcpCongestion {
        value: TcpCongestionControl,
        responder: StreamSocketSetTcpCongestionResponder,
    },
    /// Get `SOL_TCP` -> `TCP_CONGESTION`.
    GetTcpCongestion {
        responder: StreamSocketGetTcpCongestionResponder,
    },
    /// Set `SOL_TCP` -> `TCP_USER_TIMEOUT`.
    SetTcpUserTimeout {
        value_millis: u32,
        responder: StreamSocketSetTcpUserTimeoutResponder,
    },
    /// Get `SOL_TCP` -> `TCP_USER_TIMEOUT`.
    GetTcpUserTimeout {
        responder: StreamSocketGetTcpUserTimeoutResponder,
    },
}

impl StreamSocketRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_clone(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
        StreamSocketControlHandle,
    )> {
        if let StreamSocketRequest::Clone { request, control_handle } = self {
            Some((request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_close(self) -> Option<(StreamSocketCloseResponder)> {
        if let StreamSocketRequest::Close { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query(self) -> Option<(StreamSocketQueryResponder)> {
        if let StreamSocketRequest::Query { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_reuse_address(self) -> Option<(bool, StreamSocketSetReuseAddressResponder)> {
        if let StreamSocketRequest::SetReuseAddress { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_reuse_address(self) -> Option<(StreamSocketGetReuseAddressResponder)> {
        if let StreamSocketRequest::GetReuseAddress { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_error(self) -> Option<(StreamSocketGetErrorResponder)> {
        if let StreamSocketRequest::GetError { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_broadcast(self) -> Option<(bool, StreamSocketSetBroadcastResponder)> {
        if let StreamSocketRequest::SetBroadcast { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_broadcast(self) -> Option<(StreamSocketGetBroadcastResponder)> {
        if let StreamSocketRequest::GetBroadcast { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_send_buffer(self) -> Option<(u64, StreamSocketSetSendBufferResponder)> {
        if let StreamSocketRequest::SetSendBuffer { value_bytes, responder } = self {
            Some((value_bytes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_send_buffer(self) -> Option<(StreamSocketGetSendBufferResponder)> {
        if let StreamSocketRequest::GetSendBuffer { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_receive_buffer(self) -> Option<(u64, StreamSocketSetReceiveBufferResponder)> {
        if let StreamSocketRequest::SetReceiveBuffer { value_bytes, responder } = self {
            Some((value_bytes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_receive_buffer(self) -> Option<(StreamSocketGetReceiveBufferResponder)> {
        if let StreamSocketRequest::GetReceiveBuffer { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_keep_alive(self) -> Option<(bool, StreamSocketSetKeepAliveResponder)> {
        if let StreamSocketRequest::SetKeepAlive { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_keep_alive(self) -> Option<(StreamSocketGetKeepAliveResponder)> {
        if let StreamSocketRequest::GetKeepAlive { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_out_of_band_inline(
        self,
    ) -> Option<(bool, StreamSocketSetOutOfBandInlineResponder)> {
        if let StreamSocketRequest::SetOutOfBandInline { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_out_of_band_inline(self) -> Option<(StreamSocketGetOutOfBandInlineResponder)> {
        if let StreamSocketRequest::GetOutOfBandInline { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_no_check(self) -> Option<(bool, StreamSocketSetNoCheckResponder)> {
        if let StreamSocketRequest::SetNoCheck { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_no_check(self) -> Option<(StreamSocketGetNoCheckResponder)> {
        if let StreamSocketRequest::GetNoCheck { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_linger(self) -> Option<(bool, u32, StreamSocketSetLingerResponder)> {
        if let StreamSocketRequest::SetLinger { linger, length_secs, responder } = self {
            Some((linger, length_secs, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_linger(self) -> Option<(StreamSocketGetLingerResponder)> {
        if let StreamSocketRequest::GetLinger { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_reuse_port(self) -> Option<(bool, StreamSocketSetReusePortResponder)> {
        if let StreamSocketRequest::SetReusePort { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_reuse_port(self) -> Option<(StreamSocketGetReusePortResponder)> {
        if let StreamSocketRequest::GetReusePort { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_accept_conn(self) -> Option<(StreamSocketGetAcceptConnResponder)> {
        if let StreamSocketRequest::GetAcceptConn { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_bind_to_device(self) -> Option<(String, StreamSocketSetBindToDeviceResponder)> {
        if let StreamSocketRequest::SetBindToDevice { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_bind_to_device(self) -> Option<(StreamSocketGetBindToDeviceResponder)> {
        if let StreamSocketRequest::GetBindToDevice { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_bind_to_interface_index(
        self,
    ) -> Option<(u64, StreamSocketSetBindToInterfaceIndexResponder)> {
        if let StreamSocketRequest::SetBindToInterfaceIndex { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_bind_to_interface_index(
        self,
    ) -> Option<(StreamSocketGetBindToInterfaceIndexResponder)> {
        if let StreamSocketRequest::GetBindToInterfaceIndex { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_timestamp(
        self,
    ) -> Option<(TimestampOption, StreamSocketSetTimestampResponder)> {
        if let StreamSocketRequest::SetTimestamp { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_timestamp(self) -> Option<(StreamSocketGetTimestampResponder)> {
        if let StreamSocketRequest::GetTimestamp { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_mark(
        self,
    ) -> Option<(fidl_fuchsia_net::MarkDomain, OptionalUint32, StreamSocketSetMarkResponder)> {
        if let StreamSocketRequest::SetMark { domain, mark, responder } = self {
            Some((domain, mark, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_mark(
        self,
    ) -> Option<(fidl_fuchsia_net::MarkDomain, StreamSocketGetMarkResponder)> {
        if let StreamSocketRequest::GetMark { domain, responder } = self {
            Some((domain, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_cookie(self) -> Option<(StreamSocketGetCookieResponder)> {
        if let StreamSocketRequest::GetCookie { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind(self) -> Option<(fidl_fuchsia_net::SocketAddress, StreamSocketBindResponder)> {
        if let StreamSocketRequest::Bind { addr, responder } = self {
            Some((addr, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fidl_fuchsia_net::SocketAddress, StreamSocketConnectResponder)> {
        if let StreamSocketRequest::Connect { addr, responder } = self {
            Some((addr, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_disconnect(self) -> Option<(StreamSocketDisconnectResponder)> {
        if let StreamSocketRequest::Disconnect { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_sock_name(self) -> Option<(StreamSocketGetSockNameResponder)> {
        if let StreamSocketRequest::GetSockName { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_peer_name(self) -> Option<(StreamSocketGetPeerNameResponder)> {
        if let StreamSocketRequest::GetPeerName { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_shutdown(self) -> Option<(ShutdownMode, StreamSocketShutdownResponder)> {
        if let StreamSocketRequest::Shutdown { mode, responder } = self {
            Some((mode, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_type_of_service(
        self,
    ) -> Option<(u8, StreamSocketSetIpTypeOfServiceResponder)> {
        if let StreamSocketRequest::SetIpTypeOfService { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_type_of_service(self) -> Option<(StreamSocketGetIpTypeOfServiceResponder)> {
        if let StreamSocketRequest::GetIpTypeOfService { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_ttl(self) -> Option<(OptionalUint8, StreamSocketSetIpTtlResponder)> {
        if let StreamSocketRequest::SetIpTtl { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_ttl(self) -> Option<(StreamSocketGetIpTtlResponder)> {
        if let StreamSocketRequest::GetIpTtl { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_packet_info(self) -> Option<(bool, StreamSocketSetIpPacketInfoResponder)> {
        if let StreamSocketRequest::SetIpPacketInfo { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_packet_info(self) -> Option<(StreamSocketGetIpPacketInfoResponder)> {
        if let StreamSocketRequest::GetIpPacketInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_receive_type_of_service(
        self,
    ) -> Option<(bool, StreamSocketSetIpReceiveTypeOfServiceResponder)> {
        if let StreamSocketRequest::SetIpReceiveTypeOfService { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_receive_type_of_service(
        self,
    ) -> Option<(StreamSocketGetIpReceiveTypeOfServiceResponder)> {
        if let StreamSocketRequest::GetIpReceiveTypeOfService { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_receive_ttl(self) -> Option<(bool, StreamSocketSetIpReceiveTtlResponder)> {
        if let StreamSocketRequest::SetIpReceiveTtl { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_receive_ttl(self) -> Option<(StreamSocketGetIpReceiveTtlResponder)> {
        if let StreamSocketRequest::GetIpReceiveTtl { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_multicast_interface(
        self,
    ) -> Option<(u64, fidl_fuchsia_net::Ipv4Address, StreamSocketSetIpMulticastInterfaceResponder)>
    {
        if let StreamSocketRequest::SetIpMulticastInterface { iface, address, responder } = self {
            Some((iface, address, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_multicast_interface(
        self,
    ) -> Option<(StreamSocketGetIpMulticastInterfaceResponder)> {
        if let StreamSocketRequest::GetIpMulticastInterface { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_multicast_ttl(
        self,
    ) -> Option<(OptionalUint8, StreamSocketSetIpMulticastTtlResponder)> {
        if let StreamSocketRequest::SetIpMulticastTtl { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_multicast_ttl(self) -> Option<(StreamSocketGetIpMulticastTtlResponder)> {
        if let StreamSocketRequest::GetIpMulticastTtl { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_multicast_loopback(
        self,
    ) -> Option<(bool, StreamSocketSetIpMulticastLoopbackResponder)> {
        if let StreamSocketRequest::SetIpMulticastLoopback { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_multicast_loopback(
        self,
    ) -> Option<(StreamSocketGetIpMulticastLoopbackResponder)> {
        if let StreamSocketRequest::GetIpMulticastLoopback { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_ip_membership(
        self,
    ) -> Option<(IpMulticastMembership, StreamSocketAddIpMembershipResponder)> {
        if let StreamSocketRequest::AddIpMembership { membership, responder } = self {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_drop_ip_membership(
        self,
    ) -> Option<(IpMulticastMembership, StreamSocketDropIpMembershipResponder)> {
        if let StreamSocketRequest::DropIpMembership { membership, responder } = self {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_transparent(self) -> Option<(bool, StreamSocketSetIpTransparentResponder)> {
        if let StreamSocketRequest::SetIpTransparent { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_transparent(self) -> Option<(StreamSocketGetIpTransparentResponder)> {
        if let StreamSocketRequest::GetIpTransparent { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_receive_original_destination_address(
        self,
    ) -> Option<(bool, StreamSocketSetIpReceiveOriginalDestinationAddressResponder)> {
        if let StreamSocketRequest::SetIpReceiveOriginalDestinationAddress { value, responder } =
            self
        {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_receive_original_destination_address(
        self,
    ) -> Option<(StreamSocketGetIpReceiveOriginalDestinationAddressResponder)> {
        if let StreamSocketRequest::GetIpReceiveOriginalDestinationAddress { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_ipv6_membership(
        self,
    ) -> Option<(Ipv6MulticastMembership, StreamSocketAddIpv6MembershipResponder)> {
        if let StreamSocketRequest::AddIpv6Membership { membership, responder } = self {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_drop_ipv6_membership(
        self,
    ) -> Option<(Ipv6MulticastMembership, StreamSocketDropIpv6MembershipResponder)> {
        if let StreamSocketRequest::DropIpv6Membership { membership, responder } = self {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_multicast_interface(
        self,
    ) -> Option<(u64, StreamSocketSetIpv6MulticastInterfaceResponder)> {
        if let StreamSocketRequest::SetIpv6MulticastInterface { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_multicast_interface(
        self,
    ) -> Option<(StreamSocketGetIpv6MulticastInterfaceResponder)> {
        if let StreamSocketRequest::GetIpv6MulticastInterface { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_unicast_hops(
        self,
    ) -> Option<(OptionalUint8, StreamSocketSetIpv6UnicastHopsResponder)> {
        if let StreamSocketRequest::SetIpv6UnicastHops { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_unicast_hops(self) -> Option<(StreamSocketGetIpv6UnicastHopsResponder)> {
        if let StreamSocketRequest::GetIpv6UnicastHops { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_receive_hop_limit(
        self,
    ) -> Option<(bool, StreamSocketSetIpv6ReceiveHopLimitResponder)> {
        if let StreamSocketRequest::SetIpv6ReceiveHopLimit { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_receive_hop_limit(
        self,
    ) -> Option<(StreamSocketGetIpv6ReceiveHopLimitResponder)> {
        if let StreamSocketRequest::GetIpv6ReceiveHopLimit { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_multicast_hops(
        self,
    ) -> Option<(OptionalUint8, StreamSocketSetIpv6MulticastHopsResponder)> {
        if let StreamSocketRequest::SetIpv6MulticastHops { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_multicast_hops(
        self,
    ) -> Option<(StreamSocketGetIpv6MulticastHopsResponder)> {
        if let StreamSocketRequest::GetIpv6MulticastHops { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_multicast_loopback(
        self,
    ) -> Option<(bool, StreamSocketSetIpv6MulticastLoopbackResponder)> {
        if let StreamSocketRequest::SetIpv6MulticastLoopback { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_multicast_loopback(
        self,
    ) -> Option<(StreamSocketGetIpv6MulticastLoopbackResponder)> {
        if let StreamSocketRequest::GetIpv6MulticastLoopback { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_only(self) -> Option<(bool, StreamSocketSetIpv6OnlyResponder)> {
        if let StreamSocketRequest::SetIpv6Only { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_only(self) -> Option<(StreamSocketGetIpv6OnlyResponder)> {
        if let StreamSocketRequest::GetIpv6Only { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_receive_traffic_class(
        self,
    ) -> Option<(bool, StreamSocketSetIpv6ReceiveTrafficClassResponder)> {
        if let StreamSocketRequest::SetIpv6ReceiveTrafficClass { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_receive_traffic_class(
        self,
    ) -> Option<(StreamSocketGetIpv6ReceiveTrafficClassResponder)> {
        if let StreamSocketRequest::GetIpv6ReceiveTrafficClass { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_traffic_class(
        self,
    ) -> Option<(OptionalUint8, StreamSocketSetIpv6TrafficClassResponder)> {
        if let StreamSocketRequest::SetIpv6TrafficClass { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_traffic_class(self) -> Option<(StreamSocketGetIpv6TrafficClassResponder)> {
        if let StreamSocketRequest::GetIpv6TrafficClass { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_receive_packet_info(
        self,
    ) -> Option<(bool, StreamSocketSetIpv6ReceivePacketInfoResponder)> {
        if let StreamSocketRequest::SetIpv6ReceivePacketInfo { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_receive_packet_info(
        self,
    ) -> Option<(StreamSocketGetIpv6ReceivePacketInfoResponder)> {
        if let StreamSocketRequest::GetIpv6ReceivePacketInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_original_destination(
        self,
    ) -> Option<(StreamSocketGetOriginalDestinationResponder)> {
        if let StreamSocketRequest::GetOriginalDestination { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_describe(self) -> Option<(StreamSocketDescribeResponder)> {
        if let StreamSocketRequest::Describe { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_listen(self) -> Option<(i16, StreamSocketListenResponder)> {
        if let StreamSocketRequest::Listen { backlog, responder } = self {
            Some((backlog, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_accept(self) -> Option<(bool, StreamSocketAcceptResponder)> {
        if let StreamSocketRequest::Accept { want_addr, responder } = self {
            Some((want_addr, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_info(self) -> Option<(StreamSocketGetInfoResponder)> {
        if let StreamSocketRequest::GetInfo { responder } = self { Some((responder)) } else { None }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_tcp_no_delay(self) -> Option<(bool, StreamSocketSetTcpNoDelayResponder)> {
        if let StreamSocketRequest::SetTcpNoDelay { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_tcp_no_delay(self) -> Option<(StreamSocketGetTcpNoDelayResponder)> {
        if let StreamSocketRequest::GetTcpNoDelay { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_tcp_max_segment(self) -> Option<(u32, StreamSocketSetTcpMaxSegmentResponder)> {
        if let StreamSocketRequest::SetTcpMaxSegment { value_bytes, responder } = self {
            Some((value_bytes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_tcp_max_segment(self) -> Option<(StreamSocketGetTcpMaxSegmentResponder)> {
        if let StreamSocketRequest::GetTcpMaxSegment { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_tcp_cork(self) -> Option<(bool, StreamSocketSetTcpCorkResponder)> {
        if let StreamSocketRequest::SetTcpCork { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_tcp_cork(self) -> Option<(StreamSocketGetTcpCorkResponder)> {
        if let StreamSocketRequest::GetTcpCork { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_tcp_keep_alive_idle(
        self,
    ) -> Option<(u32, StreamSocketSetTcpKeepAliveIdleResponder)> {
        if let StreamSocketRequest::SetTcpKeepAliveIdle { value_secs, responder } = self {
            Some((value_secs, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_tcp_keep_alive_idle(
        self,
    ) -> Option<(StreamSocketGetTcpKeepAliveIdleResponder)> {
        if let StreamSocketRequest::GetTcpKeepAliveIdle { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_tcp_keep_alive_interval(
        self,
    ) -> Option<(u32, StreamSocketSetTcpKeepAliveIntervalResponder)> {
        if let StreamSocketRequest::SetTcpKeepAliveInterval { value_secs, responder } = self {
            Some((value_secs, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_tcp_keep_alive_interval(
        self,
    ) -> Option<(StreamSocketGetTcpKeepAliveIntervalResponder)> {
        if let StreamSocketRequest::GetTcpKeepAliveInterval { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_tcp_keep_alive_count(
        self,
    ) -> Option<(u32, StreamSocketSetTcpKeepAliveCountResponder)> {
        if let StreamSocketRequest::SetTcpKeepAliveCount { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_tcp_keep_alive_count(
        self,
    ) -> Option<(StreamSocketGetTcpKeepAliveCountResponder)> {
        if let StreamSocketRequest::GetTcpKeepAliveCount { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_tcp_syn_count(self) -> Option<(u32, StreamSocketSetTcpSynCountResponder)> {
        if let StreamSocketRequest::SetTcpSynCount { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_tcp_syn_count(self) -> Option<(StreamSocketGetTcpSynCountResponder)> {
        if let StreamSocketRequest::GetTcpSynCount { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_tcp_linger(
        self,
    ) -> Option<(OptionalUint32, StreamSocketSetTcpLingerResponder)> {
        if let StreamSocketRequest::SetTcpLinger { value_secs, responder } = self {
            Some((value_secs, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_tcp_linger(self) -> Option<(StreamSocketGetTcpLingerResponder)> {
        if let StreamSocketRequest::GetTcpLinger { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_tcp_defer_accept(
        self,
    ) -> Option<(u32, StreamSocketSetTcpDeferAcceptResponder)> {
        if let StreamSocketRequest::SetTcpDeferAccept { value_secs, responder } = self {
            Some((value_secs, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_tcp_defer_accept(self) -> Option<(StreamSocketGetTcpDeferAcceptResponder)> {
        if let StreamSocketRequest::GetTcpDeferAccept { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_tcp_window_clamp(
        self,
    ) -> Option<(u32, StreamSocketSetTcpWindowClampResponder)> {
        if let StreamSocketRequest::SetTcpWindowClamp { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_tcp_window_clamp(self) -> Option<(StreamSocketGetTcpWindowClampResponder)> {
        if let StreamSocketRequest::GetTcpWindowClamp { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_tcp_info(self) -> Option<(StreamSocketGetTcpInfoResponder)> {
        if let StreamSocketRequest::GetTcpInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_tcp_quick_ack(self) -> Option<(bool, StreamSocketSetTcpQuickAckResponder)> {
        if let StreamSocketRequest::SetTcpQuickAck { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_tcp_quick_ack(self) -> Option<(StreamSocketGetTcpQuickAckResponder)> {
        if let StreamSocketRequest::GetTcpQuickAck { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_tcp_congestion(
        self,
    ) -> Option<(TcpCongestionControl, StreamSocketSetTcpCongestionResponder)> {
        if let StreamSocketRequest::SetTcpCongestion { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_tcp_congestion(self) -> Option<(StreamSocketGetTcpCongestionResponder)> {
        if let StreamSocketRequest::GetTcpCongestion { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_tcp_user_timeout(
        self,
    ) -> Option<(u32, StreamSocketSetTcpUserTimeoutResponder)> {
        if let StreamSocketRequest::SetTcpUserTimeout { value_millis, responder } = self {
            Some((value_millis, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_tcp_user_timeout(self) -> Option<(StreamSocketGetTcpUserTimeoutResponder)> {
        if let StreamSocketRequest::GetTcpUserTimeout { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            StreamSocketRequest::Clone { .. } => "clone",
            StreamSocketRequest::Close { .. } => "close",
            StreamSocketRequest::Query { .. } => "query",
            StreamSocketRequest::SetReuseAddress { .. } => "set_reuse_address",
            StreamSocketRequest::GetReuseAddress { .. } => "get_reuse_address",
            StreamSocketRequest::GetError { .. } => "get_error",
            StreamSocketRequest::SetBroadcast { .. } => "set_broadcast",
            StreamSocketRequest::GetBroadcast { .. } => "get_broadcast",
            StreamSocketRequest::SetSendBuffer { .. } => "set_send_buffer",
            StreamSocketRequest::GetSendBuffer { .. } => "get_send_buffer",
            StreamSocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
            StreamSocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
            StreamSocketRequest::SetKeepAlive { .. } => "set_keep_alive",
            StreamSocketRequest::GetKeepAlive { .. } => "get_keep_alive",
            StreamSocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
            StreamSocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
            StreamSocketRequest::SetNoCheck { .. } => "set_no_check",
            StreamSocketRequest::GetNoCheck { .. } => "get_no_check",
            StreamSocketRequest::SetLinger { .. } => "set_linger",
            StreamSocketRequest::GetLinger { .. } => "get_linger",
            StreamSocketRequest::SetReusePort { .. } => "set_reuse_port",
            StreamSocketRequest::GetReusePort { .. } => "get_reuse_port",
            StreamSocketRequest::GetAcceptConn { .. } => "get_accept_conn",
            StreamSocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
            StreamSocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
            StreamSocketRequest::SetBindToInterfaceIndex { .. } => "set_bind_to_interface_index",
            StreamSocketRequest::GetBindToInterfaceIndex { .. } => "get_bind_to_interface_index",
            StreamSocketRequest::SetTimestamp { .. } => "set_timestamp",
            StreamSocketRequest::GetTimestamp { .. } => "get_timestamp",
            StreamSocketRequest::SetMark { .. } => "set_mark",
            StreamSocketRequest::GetMark { .. } => "get_mark",
            StreamSocketRequest::GetCookie { .. } => "get_cookie",
            StreamSocketRequest::Bind { .. } => "bind",
            StreamSocketRequest::Connect { .. } => "connect",
            StreamSocketRequest::Disconnect { .. } => "disconnect",
            StreamSocketRequest::GetSockName { .. } => "get_sock_name",
            StreamSocketRequest::GetPeerName { .. } => "get_peer_name",
            StreamSocketRequest::Shutdown { .. } => "shutdown",
            StreamSocketRequest::SetIpTypeOfService { .. } => "set_ip_type_of_service",
            StreamSocketRequest::GetIpTypeOfService { .. } => "get_ip_type_of_service",
            StreamSocketRequest::SetIpTtl { .. } => "set_ip_ttl",
            StreamSocketRequest::GetIpTtl { .. } => "get_ip_ttl",
            StreamSocketRequest::SetIpPacketInfo { .. } => "set_ip_packet_info",
            StreamSocketRequest::GetIpPacketInfo { .. } => "get_ip_packet_info",
            StreamSocketRequest::SetIpReceiveTypeOfService { .. } => {
                "set_ip_receive_type_of_service"
            }
            StreamSocketRequest::GetIpReceiveTypeOfService { .. } => {
                "get_ip_receive_type_of_service"
            }
            StreamSocketRequest::SetIpReceiveTtl { .. } => "set_ip_receive_ttl",
            StreamSocketRequest::GetIpReceiveTtl { .. } => "get_ip_receive_ttl",
            StreamSocketRequest::SetIpMulticastInterface { .. } => "set_ip_multicast_interface",
            StreamSocketRequest::GetIpMulticastInterface { .. } => "get_ip_multicast_interface",
            StreamSocketRequest::SetIpMulticastTtl { .. } => "set_ip_multicast_ttl",
            StreamSocketRequest::GetIpMulticastTtl { .. } => "get_ip_multicast_ttl",
            StreamSocketRequest::SetIpMulticastLoopback { .. } => "set_ip_multicast_loopback",
            StreamSocketRequest::GetIpMulticastLoopback { .. } => "get_ip_multicast_loopback",
            StreamSocketRequest::AddIpMembership { .. } => "add_ip_membership",
            StreamSocketRequest::DropIpMembership { .. } => "drop_ip_membership",
            StreamSocketRequest::SetIpTransparent { .. } => "set_ip_transparent",
            StreamSocketRequest::GetIpTransparent { .. } => "get_ip_transparent",
            StreamSocketRequest::SetIpReceiveOriginalDestinationAddress { .. } => {
                "set_ip_receive_original_destination_address"
            }
            StreamSocketRequest::GetIpReceiveOriginalDestinationAddress { .. } => {
                "get_ip_receive_original_destination_address"
            }
            StreamSocketRequest::AddIpv6Membership { .. } => "add_ipv6_membership",
            StreamSocketRequest::DropIpv6Membership { .. } => "drop_ipv6_membership",
            StreamSocketRequest::SetIpv6MulticastInterface { .. } => "set_ipv6_multicast_interface",
            StreamSocketRequest::GetIpv6MulticastInterface { .. } => "get_ipv6_multicast_interface",
            StreamSocketRequest::SetIpv6UnicastHops { .. } => "set_ipv6_unicast_hops",
            StreamSocketRequest::GetIpv6UnicastHops { .. } => "get_ipv6_unicast_hops",
            StreamSocketRequest::SetIpv6ReceiveHopLimit { .. } => "set_ipv6_receive_hop_limit",
            StreamSocketRequest::GetIpv6ReceiveHopLimit { .. } => "get_ipv6_receive_hop_limit",
            StreamSocketRequest::SetIpv6MulticastHops { .. } => "set_ipv6_multicast_hops",
            StreamSocketRequest::GetIpv6MulticastHops { .. } => "get_ipv6_multicast_hops",
            StreamSocketRequest::SetIpv6MulticastLoopback { .. } => "set_ipv6_multicast_loopback",
            StreamSocketRequest::GetIpv6MulticastLoopback { .. } => "get_ipv6_multicast_loopback",
            StreamSocketRequest::SetIpv6Only { .. } => "set_ipv6_only",
            StreamSocketRequest::GetIpv6Only { .. } => "get_ipv6_only",
            StreamSocketRequest::SetIpv6ReceiveTrafficClass { .. } => {
                "set_ipv6_receive_traffic_class"
            }
            StreamSocketRequest::GetIpv6ReceiveTrafficClass { .. } => {
                "get_ipv6_receive_traffic_class"
            }
            StreamSocketRequest::SetIpv6TrafficClass { .. } => "set_ipv6_traffic_class",
            StreamSocketRequest::GetIpv6TrafficClass { .. } => "get_ipv6_traffic_class",
            StreamSocketRequest::SetIpv6ReceivePacketInfo { .. } => "set_ipv6_receive_packet_info",
            StreamSocketRequest::GetIpv6ReceivePacketInfo { .. } => "get_ipv6_receive_packet_info",
            StreamSocketRequest::GetOriginalDestination { .. } => "get_original_destination",
            StreamSocketRequest::Describe { .. } => "describe",
            StreamSocketRequest::Listen { .. } => "listen",
            StreamSocketRequest::Accept { .. } => "accept",
            StreamSocketRequest::GetInfo { .. } => "get_info",
            StreamSocketRequest::SetTcpNoDelay { .. } => "set_tcp_no_delay",
            StreamSocketRequest::GetTcpNoDelay { .. } => "get_tcp_no_delay",
            StreamSocketRequest::SetTcpMaxSegment { .. } => "set_tcp_max_segment",
            StreamSocketRequest::GetTcpMaxSegment { .. } => "get_tcp_max_segment",
            StreamSocketRequest::SetTcpCork { .. } => "set_tcp_cork",
            StreamSocketRequest::GetTcpCork { .. } => "get_tcp_cork",
            StreamSocketRequest::SetTcpKeepAliveIdle { .. } => "set_tcp_keep_alive_idle",
            StreamSocketRequest::GetTcpKeepAliveIdle { .. } => "get_tcp_keep_alive_idle",
            StreamSocketRequest::SetTcpKeepAliveInterval { .. } => "set_tcp_keep_alive_interval",
            StreamSocketRequest::GetTcpKeepAliveInterval { .. } => "get_tcp_keep_alive_interval",
            StreamSocketRequest::SetTcpKeepAliveCount { .. } => "set_tcp_keep_alive_count",
            StreamSocketRequest::GetTcpKeepAliveCount { .. } => "get_tcp_keep_alive_count",
            StreamSocketRequest::SetTcpSynCount { .. } => "set_tcp_syn_count",
            StreamSocketRequest::GetTcpSynCount { .. } => "get_tcp_syn_count",
            StreamSocketRequest::SetTcpLinger { .. } => "set_tcp_linger",
            StreamSocketRequest::GetTcpLinger { .. } => "get_tcp_linger",
            StreamSocketRequest::SetTcpDeferAccept { .. } => "set_tcp_defer_accept",
            StreamSocketRequest::GetTcpDeferAccept { .. } => "get_tcp_defer_accept",
            StreamSocketRequest::SetTcpWindowClamp { .. } => "set_tcp_window_clamp",
            StreamSocketRequest::GetTcpWindowClamp { .. } => "get_tcp_window_clamp",
            StreamSocketRequest::GetTcpInfo { .. } => "get_tcp_info",
            StreamSocketRequest::SetTcpQuickAck { .. } => "set_tcp_quick_ack",
            StreamSocketRequest::GetTcpQuickAck { .. } => "get_tcp_quick_ack",
            StreamSocketRequest::SetTcpCongestion { .. } => "set_tcp_congestion",
            StreamSocketRequest::GetTcpCongestion { .. } => "get_tcp_congestion",
            StreamSocketRequest::SetTcpUserTimeout { .. } => "set_tcp_user_timeout",
            StreamSocketRequest::GetTcpUserTimeout { .. } => "get_tcp_user_timeout",
        }
    }
}

#[derive(Debug, Clone)]
pub struct StreamSocketControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for StreamSocketControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl StreamSocketControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketCloseResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketCloseResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketCloseResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketCloseResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
                result,
                self.tx_id,
                0x5ac5d459ad7f657e,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketQueryResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketQueryResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketQueryResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketQueryResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(protocol);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(protocol);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
            (protocol,),
            self.tx_id,
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetReuseAddressResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetReuseAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetReuseAddressResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetReuseAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x1fd74ee8b9a4a876,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetReuseAddressResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetReuseAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetReuseAddressResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetReuseAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetReuseAddressResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x67b7206b8d1bc0a5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetErrorResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetErrorResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetErrorResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetErrorResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x5aad39b33e5f6ebb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetBroadcastResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetBroadcastResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetBroadcastResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetBroadcastResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6023e081ce3cd947,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetBroadcastResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetBroadcastResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetBroadcastResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetBroadcastResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetBroadcastResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x68796fc556f9780d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetSendBufferResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetSendBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetSendBufferResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetSendBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x756eac32d73a7a70,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetSendBufferResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetSendBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetSendBufferResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetSendBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetSendBufferResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value_bytes| (value_bytes,)),
            self.tx_id,
            0x78a52fd9c7b2410b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetReceiveBufferResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetReceiveBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetReceiveBufferResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetReceiveBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6b0cf2f1919c7001,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetReceiveBufferResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetReceiveBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetReceiveBufferResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetReceiveBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetReceiveBufferResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value_bytes| (value_bytes,)),
            self.tx_id,
            0x14c1a4b64f709e5c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetKeepAliveResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetKeepAliveResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetKeepAliveResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetKeepAliveResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x572df8f0b920d2c7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetKeepAliveResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetKeepAliveResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetKeepAliveResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetKeepAliveResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetKeepAliveResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2dd29d3215f2c9d2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetOutOfBandInlineResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetOutOfBandInlineResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetOutOfBandInlineResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetOutOfBandInlineResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x3ecb49968bee439,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetOutOfBandInlineResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetOutOfBandInlineResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetOutOfBandInlineResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetOutOfBandInlineResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetOutOfBandInlineResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x348c1ab3aeca1745,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetNoCheckResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetNoCheckResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetNoCheckResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetNoCheckResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6bbf00c53a4c78c2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetNoCheckResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetNoCheckResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetNoCheckResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetNoCheckResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetNoCheckResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2cd4249286417694,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetLingerResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetLingerResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetLingerResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetLingerResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x45386351246e998e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetLingerResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetLingerResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetLingerResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetLingerResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetLingerResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x48eb20fc5ccb0e45,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetReusePortResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetReusePortResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetReusePortResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetReusePortResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x24dd3e5cb36d9ccb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetReusePortResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetReusePortResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetReusePortResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetReusePortResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetReusePortResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x7a112c1ab54ff828,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetAcceptConnResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetAcceptConnResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetAcceptConnResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetAcceptConnResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetAcceptConnResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x67ce6db6c2ec8966,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetBindToDeviceResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetBindToDeviceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetBindToDeviceResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetBindToDeviceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x2118b483f28aafc4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetBindToDeviceResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetBindToDeviceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetBindToDeviceResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetBindToDeviceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetBindToDeviceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x1ab1fbf0ef7906c8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetBindToInterfaceIndexResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetBindToInterfaceIndexResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetBindToInterfaceIndexResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetBindToInterfaceIndexResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6e387a0def00821,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetBindToInterfaceIndexResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetBindToInterfaceIndexResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetBindToInterfaceIndexResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetBindToInterfaceIndexResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetBindToInterfaceIndexResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x59c31dd3e3078295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetTimestampResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetTimestampResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetTimestampResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetTimestampResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x285d6516c263d839,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetTimestampResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetTimestampResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetTimestampResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetTimestampResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetTimestampResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x49f2fffbbcc2bd27,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetMarkResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetMarkResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetMarkResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetMarkResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6ead6de09f653236,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetMarkResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetMarkResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetMarkResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetMarkResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetMarkResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|mark| (mark,)),
            self.tx_id,
            0x57a2752c61d93d47,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetCookieResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetCookieResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetCookieResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetCookieResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetCookieResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2c2f47fd8f924e52,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketBindResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketBindResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketBindResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketBindResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x4bc6400ae92125d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketConnectResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketConnectResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketConnectResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketConnectResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x5f05f19bfdd38871,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketDisconnectResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketDisconnectResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketDisconnectResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketDisconnectResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x74e63b91f7b29b2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetSockNameResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetSockNameResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetSockNameResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetSockNameResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetSockNameResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|addr| (addr,)),
            self.tx_id,
            0x475f23f84a1a4f85,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetPeerNameResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetPeerNameResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetPeerNameResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetPeerNameResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetPeerNameResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|addr| (addr,)),
            self.tx_id,
            0x1ffecf4bd5b6432e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketShutdownResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketShutdownResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketShutdownResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketShutdownResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x247f38b6db68c336,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpTypeOfServiceResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x995c600475b6d46,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpTypeOfServiceResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpTypeOfServiceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x3814a04259f75fcb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpTtlResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpTtlResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x29e2424b433ae1ef,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpTtlResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpTtlResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpTtlResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x47e47fa1f24da471,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpPacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpPacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpPacketInfoResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpPacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x392d16bee20c0e16,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpPacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpPacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpPacketInfoResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpPacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpPacketInfoResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x54b505f242280740,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpReceiveTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpReceiveTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpReceiveTypeOfServiceResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpReceiveTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6c4f6714995f84ef,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpReceiveTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpReceiveTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpReceiveTypeOfServiceResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpReceiveTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4158ba7dc2795960,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpReceiveTtlResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpReceiveTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpReceiveTtlResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpReceiveTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x46f15be0ce0ab82b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpReceiveTtlResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpReceiveTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpReceiveTtlResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpReceiveTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpReceiveTtlResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x678ddd5a5dfa2eb5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpMulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpMulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpMulticastInterfaceResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpMulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x752fbfa9b12befe,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpMulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpMulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpMulticastInterfaceResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpMulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpMulticastInterfaceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x320bd14c4df046c4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpMulticastTtlResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpMulticastTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpMulticastTtlResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpMulticastTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x63134d53772916a1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpMulticastTtlResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpMulticastTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpMulticastTtlResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpMulticastTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpMulticastTtlResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4665cd378f39e1a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpMulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpMulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpMulticastLoopbackResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpMulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x20c55c11f00943ea,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpMulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpMulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpMulticastLoopbackResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpMulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpMulticastLoopbackResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x3b6b26ff558298f2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketAddIpMembershipResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketAddIpMembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketAddIpMembershipResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketAddIpMembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x76bc7df115a3b4d0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketDropIpMembershipResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketDropIpMembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketDropIpMembershipResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketDropIpMembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x2888f3099188d03,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpTransparentResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpTransparentResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpTransparentResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpTransparentResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x1ae532b0c066e3a0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpTransparentResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpTransparentResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpTransparentResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpTransparentResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpTransparentResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x51d43695962ebfb5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpReceiveOriginalDestinationAddressResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpReceiveOriginalDestinationAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpReceiveOriginalDestinationAddressResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpReceiveOriginalDestinationAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x4722b4ce52f7840,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpReceiveOriginalDestinationAddressResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpReceiveOriginalDestinationAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpReceiveOriginalDestinationAddressResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpReceiveOriginalDestinationAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2a0e7dc5d6bfdfe9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketAddIpv6MembershipResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketAddIpv6MembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketAddIpv6MembershipResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketAddIpv6MembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x7c94727acb4ea4b3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketDropIpv6MembershipResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketDropIpv6MembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketDropIpv6MembershipResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketDropIpv6MembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x42104c70ccaba304,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpv6MulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpv6MulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpv6MulticastInterfaceResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpv6MulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x135f76db3774ab3b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpv6MulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpv6MulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpv6MulticastInterfaceResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpv6MulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x1f26fcdd348f1882,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpv6UnicastHopsResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpv6UnicastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpv6UnicastHopsResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpv6UnicastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x157d51e98f462859,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpv6UnicastHopsResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpv6UnicastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpv6UnicastHopsResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpv6UnicastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6UnicastHopsResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x21f4641cad8bd8d2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpv6ReceiveHopLimitResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpv6ReceiveHopLimitResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpv6ReceiveHopLimitResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpv6ReceiveHopLimitResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x5c24808ed2e84a1e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpv6ReceiveHopLimitResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpv6ReceiveHopLimitResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpv6ReceiveHopLimitResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpv6ReceiveHopLimitResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x341e06689885b4c0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpv6MulticastHopsResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpv6MulticastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpv6MulticastHopsResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpv6MulticastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x25b9cd4d181f82c1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpv6MulticastHopsResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpv6MulticastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpv6MulticastHopsResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpv6MulticastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6MulticastHopsResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x52916948a365012a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpv6MulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpv6MulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpv6MulticastLoopbackResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpv6MulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x55701c409ff41b40,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpv6MulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpv6MulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpv6MulticastLoopbackResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpv6MulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4415b701fde319c3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpv6OnlyResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpv6OnlyResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpv6OnlyResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpv6OnlyResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x4873f1364758cbba,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpv6OnlyResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpv6OnlyResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpv6OnlyResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpv6OnlyResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6OnlyResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4aa3340a1a26b89c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpv6ReceiveTrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpv6ReceiveTrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpv6ReceiveTrafficClassResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpv6ReceiveTrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x58f07c8788d099a0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpv6ReceiveTrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpv6ReceiveTrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpv6ReceiveTrafficClassResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpv6ReceiveTrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2e334df1da553ffa,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpv6TrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpv6TrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpv6TrafficClassResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpv6TrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6af077800c5a0b4f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpv6TrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpv6TrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpv6TrafficClassResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpv6TrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6TrafficClassResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x6baf6eed8fc2f04,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetIpv6ReceivePacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetIpv6ReceivePacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetIpv6ReceivePacketInfoResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetIpv6ReceivePacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x19259775b1a92768,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetIpv6ReceivePacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetIpv6ReceivePacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetIpv6ReceivePacketInfoResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetIpv6ReceivePacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x7acd4a2775baec75,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetOriginalDestinationResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetOriginalDestinationResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetOriginalDestinationResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetOriginalDestinationResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetOriginalDestinationResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x38bf28f0dafdbac0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketDescribeResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketDescribeResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketDescribeResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketDescribeResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut payload: StreamSocketDescribeResponse) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut payload: StreamSocketDescribeResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut payload: StreamSocketDescribeResponse) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<StreamSocketDescribeResponse>(
            &mut payload,
            self.tx_id,
            0x29e22969a7dadc32,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketListenResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketListenResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketListenResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketListenResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x3d0a65ced3d10108,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketAcceptResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketAcceptResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketAcceptResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketAcceptResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<
            (
                Option<&fidl_fuchsia_net::SocketAddress>,
                fidl::endpoints::ClientEnd<StreamSocketMarker>,
            ),
            fidl_fuchsia_posix::Errno,
        >,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<
            (
                Option<&fidl_fuchsia_net::SocketAddress>,
                fidl::endpoints::ClientEnd<StreamSocketMarker>,
            ),
            fidl_fuchsia_posix::Errno,
        >,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<
            (
                Option<&fidl_fuchsia_net::SocketAddress>,
                fidl::endpoints::ClientEnd<StreamSocketMarker>,
            ),
            fidl_fuchsia_posix::Errno,
        >,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            StreamSocketAcceptResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x5ab7ad620424c163,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetInfoResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetInfoResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(Domain, StreamSocketProtocol), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(Domain, StreamSocketProtocol), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(Domain, StreamSocketProtocol), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            StreamSocketGetInfoResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x87cfa55d19f878f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetTcpNoDelayResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetTcpNoDelayResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetTcpNoDelayResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetTcpNoDelayResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x5a59b778f7333ada,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetTcpNoDelayResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetTcpNoDelayResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetTcpNoDelayResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetTcpNoDelayResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            StreamSocketGetTcpNoDelayResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0xac219a3218b0799,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetTcpMaxSegmentResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetTcpMaxSegmentResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetTcpMaxSegmentResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetTcpMaxSegmentResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0xb3d30c498266d18,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetTcpMaxSegmentResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetTcpMaxSegmentResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetTcpMaxSegmentResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetTcpMaxSegmentResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            StreamSocketGetTcpMaxSegmentResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value_bytes| (value_bytes,)),
            self.tx_id,
            0x637404d1b4b9982c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetTcpCorkResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetTcpCorkResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetTcpCorkResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetTcpCorkResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x62e26891541143a0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetTcpCorkResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetTcpCorkResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetTcpCorkResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetTcpCorkResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            StreamSocketGetTcpCorkResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x435bb232e0e74f32,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetTcpKeepAliveIdleResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetTcpKeepAliveIdleResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetTcpKeepAliveIdleResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetTcpKeepAliveIdleResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x196d053d8363c42,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetTcpKeepAliveIdleResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetTcpKeepAliveIdleResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetTcpKeepAliveIdleResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetTcpKeepAliveIdleResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            StreamSocketGetTcpKeepAliveIdleResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value_secs| (value_secs,)),
            self.tx_id,
            0x35ec58564879dac,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetTcpKeepAliveIntervalResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetTcpKeepAliveIntervalResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetTcpKeepAliveIntervalResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetTcpKeepAliveIntervalResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x485ffbc2da1243f2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetTcpKeepAliveIntervalResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetTcpKeepAliveIntervalResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetTcpKeepAliveIntervalResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetTcpKeepAliveIntervalResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            StreamSocketGetTcpKeepAliveIntervalResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value_secs| (value_secs,)),
            self.tx_id,
            0x264eaf46306b284,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetTcpKeepAliveCountResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetTcpKeepAliveCountResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetTcpKeepAliveCountResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetTcpKeepAliveCountResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x2ab2e8c111708421,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetTcpKeepAliveCountResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetTcpKeepAliveCountResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetTcpKeepAliveCountResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetTcpKeepAliveCountResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            StreamSocketGetTcpKeepAliveCountResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2f176ae271fe7a09,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetTcpSynCountResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetTcpSynCountResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetTcpSynCountResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetTcpSynCountResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x4dcd6ab5573c1eb3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetTcpSynCountResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetTcpSynCountResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetTcpSynCountResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetTcpSynCountResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            StreamSocketGetTcpSynCountResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x7d457cba8f5f3ee6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetTcpLingerResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetTcpLingerResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetTcpLingerResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetTcpLingerResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0xd5cc1e8654d36e4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetTcpLingerResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetTcpLingerResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetTcpLingerResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetTcpLingerResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            StreamSocketGetTcpLingerResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value_secs| (value_secs,)),
            self.tx_id,
            0xad870d311cf30eb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetTcpDeferAcceptResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetTcpDeferAcceptResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetTcpDeferAcceptResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetTcpDeferAcceptResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x15092f181e57c404,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetTcpDeferAcceptResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetTcpDeferAcceptResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetTcpDeferAcceptResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetTcpDeferAcceptResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            StreamSocketGetTcpDeferAcceptResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value_secs| (value_secs,)),
            self.tx_id,
            0x64589790842cb7c6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetTcpWindowClampResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetTcpWindowClampResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetTcpWindowClampResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetTcpWindowClampResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x4a26ce07d847f1c6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetTcpWindowClampResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetTcpWindowClampResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetTcpWindowClampResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetTcpWindowClampResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            StreamSocketGetTcpWindowClampResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2df6b636bf0a6a4e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetTcpInfoResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetTcpInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetTcpInfoResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetTcpInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&TcpInfo, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&TcpInfo, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&TcpInfo, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            StreamSocketGetTcpInfoResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|info| (info,)),
            self.tx_id,
            0x1ffb123d9f03ead2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetTcpQuickAckResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetTcpQuickAckResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetTcpQuickAckResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetTcpQuickAckResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6fa811be8fde7457,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetTcpQuickAckResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetTcpQuickAckResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetTcpQuickAckResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetTcpQuickAckResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            StreamSocketGetTcpQuickAckResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x7356a949bef2df32,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetTcpCongestionResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetTcpCongestionResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetTcpCongestionResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetTcpCongestionResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x7924c6eabde7819e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetTcpCongestionResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetTcpCongestionResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetTcpCongestionResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetTcpCongestionResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<TcpCongestionControl, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<TcpCongestionControl, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<TcpCongestionControl, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            StreamSocketGetTcpCongestionResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x11e16397e1b72a47,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketSetTcpUserTimeoutResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketSetTcpUserTimeoutResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketSetTcpUserTimeoutResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketSetTcpUserTimeoutResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6b459e81c3741a60,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct StreamSocketGetTcpUserTimeoutResponder {
    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for StreamSocketGetTcpUserTimeoutResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for StreamSocketGetTcpUserTimeoutResponder {
    type ControlHandle = StreamSocketControlHandle;

    fn control_handle(&self) -> &StreamSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl StreamSocketGetTcpUserTimeoutResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            StreamSocketGetTcpUserTimeoutResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value_millis| (value_millis,)),
            self.tx_id,
            0x24bbd5858ad8c380,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct SynchronousDatagramSocketMarker;

impl fidl::endpoints::ProtocolMarker for SynchronousDatagramSocketMarker {
    type Proxy = SynchronousDatagramSocketProxy;
    type RequestStream = SynchronousDatagramSocketRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = SynchronousDatagramSocketSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.posix.socket.SynchronousDatagramSocket";
}
impl fidl::endpoints::DiscoverableProtocolMarker for SynchronousDatagramSocketMarker {}
pub type SynchronousDatagramSocketRecvMsgResult = Result<
    (Option<Box<fidl_fuchsia_net::SocketAddress>>, Vec<u8>, DatagramSocketRecvControlData, u32),
    fidl_fuchsia_posix::Errno,
>;
pub type SynchronousDatagramSocketSendMsgResult = Result<i64, fidl_fuchsia_posix::Errno>;

pub trait SynchronousDatagramSocketProxyInterface: Send + Sync {
    fn r#clone(
        &self,
        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error>;
    type CloseResponseFut: std::future::Future<
            Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
        > + Send;
    fn r#close(&self) -> Self::CloseResponseFut;
    type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
    fn r#query(&self) -> Self::QueryResponseFut;
    type SetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketSetReuseAddressResult, fidl::Error>>
        + Send;
    fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
    type GetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketGetReuseAddressResult, fidl::Error>>
        + Send;
    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
    type GetErrorResponseFut: std::future::Future<Output = Result<BaseSocketGetErrorResult, fidl::Error>>
        + Send;
    fn r#get_error(&self) -> Self::GetErrorResponseFut;
    type SetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketSetBroadcastResult, fidl::Error>>
        + Send;
    fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
    type GetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketGetBroadcastResult, fidl::Error>>
        + Send;
    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
    type SetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetSendBufferResult, fidl::Error>>
        + Send;
    fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
    type GetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetSendBufferResult, fidl::Error>>
        + Send;
    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
    type SetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetReceiveBufferResult, fidl::Error>>
        + Send;
    fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
    type GetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetReceiveBufferResult, fidl::Error>>
        + Send;
    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
    type SetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketSetKeepAliveResult, fidl::Error>>
        + Send;
    fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
    type GetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketGetKeepAliveResult, fidl::Error>>
        + Send;
    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
    type SetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketSetOutOfBandInlineResult, fidl::Error>>
        + Send;
    fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
    type GetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketGetOutOfBandInlineResult, fidl::Error>>
        + Send;
    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
    type SetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketSetNoCheckResult, fidl::Error>>
        + Send;
    fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
    type GetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketGetNoCheckResult, fidl::Error>>
        + Send;
    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
    type SetLingerResponseFut: std::future::Future<Output = Result<BaseSocketSetLingerResult, fidl::Error>>
        + Send;
    fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
    type GetLingerResponseFut: std::future::Future<Output = Result<BaseSocketGetLingerResult, fidl::Error>>
        + Send;
    fn r#get_linger(&self) -> Self::GetLingerResponseFut;
    type SetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketSetReusePortResult, fidl::Error>>
        + Send;
    fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
    type GetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketGetReusePortResult, fidl::Error>>
        + Send;
    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
    type GetAcceptConnResponseFut: std::future::Future<Output = Result<BaseSocketGetAcceptConnResult, fidl::Error>>
        + Send;
    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
    type SetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToDeviceResult, fidl::Error>>
        + Send;
    fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
    type GetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToDeviceResult, fidl::Error>>
        + Send;
    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
    type SetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error>>
        + Send;
    fn r#set_bind_to_interface_index(&self, value: u64)
    -> Self::SetBindToInterfaceIndexResponseFut;
    type GetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error>>
        + Send;
    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
    type SetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketSetTimestampResult, fidl::Error>>
        + Send;
    fn r#set_timestamp(&self, value: TimestampOption) -> Self::SetTimestampResponseFut;
    type GetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketGetTimestampResult, fidl::Error>>
        + Send;
    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
    type SetMarkResponseFut: std::future::Future<Output = Result<BaseSocketSetMarkResult, fidl::Error>>
        + Send;
    fn r#set_mark(
        &self,
        domain: fidl_fuchsia_net::MarkDomain,
        mark: &OptionalUint32,
    ) -> Self::SetMarkResponseFut;
    type GetMarkResponseFut: std::future::Future<Output = Result<BaseSocketGetMarkResult, fidl::Error>>
        + Send;
    fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
    type GetCookieResponseFut: std::future::Future<Output = Result<BaseSocketGetCookieResult, fidl::Error>>
        + Send;
    fn r#get_cookie(&self) -> Self::GetCookieResponseFut;
    type BindResponseFut: std::future::Future<Output = Result<BaseNetworkSocketBindResult, fidl::Error>>
        + Send;
    fn r#bind(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut;
    type ConnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketConnectResult, fidl::Error>>
        + Send;
    fn r#connect(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut;
    type DisconnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDisconnectResult, fidl::Error>>
        + Send;
    fn r#disconnect(&self) -> Self::DisconnectResponseFut;
    type GetSockNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetSockNameResult, fidl::Error>>
        + Send;
    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut;
    type GetPeerNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetPeerNameResult, fidl::Error>>
        + Send;
    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut;
    type ShutdownResponseFut: std::future::Future<Output = Result<BaseNetworkSocketShutdownResult, fidl::Error>>
        + Send;
    fn r#shutdown(&self, mode: ShutdownMode) -> Self::ShutdownResponseFut;
    type SetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>>
        + Send;
    fn r#set_ip_type_of_service(&self, value: u8) -> Self::SetIpTypeOfServiceResponseFut;
    type GetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>>
        + Send;
    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut;
    type SetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTtlResult, fidl::Error>>
        + Send;
    fn r#set_ip_ttl(&self, value: &OptionalUint8) -> Self::SetIpTtlResponseFut;
    type GetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTtlResult, fidl::Error>>
        + Send;
    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut;
    type SetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>>
        + Send;
    fn r#set_ip_packet_info(&self, value: bool) -> Self::SetIpPacketInfoResponseFut;
    type GetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>>
        + Send;
    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut;
    type SetIpReceiveTypeOfServiceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error>,
        > + Send;
    fn r#set_ip_receive_type_of_service(
        &self,
        value: bool,
    ) -> Self::SetIpReceiveTypeOfServiceResponseFut;
    type GetIpReceiveTypeOfServiceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error>,
        > + Send;
    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut;
    type SetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>>
        + Send;
    fn r#set_ip_receive_ttl(&self, value: bool) -> Self::SetIpReceiveTtlResponseFut;
    type GetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>>
        + Send;
    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut;
    type SetIpMulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#set_ip_multicast_interface(
        &self,
        iface: u64,
        address: &fidl_fuchsia_net::Ipv4Address,
    ) -> Self::SetIpMulticastInterfaceResponseFut;
    type GetIpMulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut;
    type SetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>>
        + Send;
    fn r#set_ip_multicast_ttl(&self, value: &OptionalUint8) -> Self::SetIpMulticastTtlResponseFut;
    type GetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>>
        + Send;
    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut;
    type SetIpMulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#set_ip_multicast_loopback(&self, value: bool) -> Self::SetIpMulticastLoopbackResponseFut;
    type GetIpMulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut;
    type AddIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error>>
        + Send;
    fn r#add_ip_membership(
        &self,
        membership: &IpMulticastMembership,
    ) -> Self::AddIpMembershipResponseFut;
    type DropIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error>>
        + Send;
    fn r#drop_ip_membership(
        &self,
        membership: &IpMulticastMembership,
    ) -> Self::DropIpMembershipResponseFut;
    type SetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error>>
        + Send;
    fn r#set_ip_transparent(&self, value: bool) -> Self::SetIpTransparentResponseFut;
    type GetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error>>
        + Send;
    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut;
    type SetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
            Output = Result<
                BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
                fidl::Error,
            >,
        > + Send;
    fn r#set_ip_receive_original_destination_address(
        &self,
        value: bool,
    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut;
    type GetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
            Output = Result<
                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
                fidl::Error,
            >,
        > + Send;
    fn r#get_ip_receive_original_destination_address(
        &self,
    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut;
    type AddIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>>
        + Send;
    fn r#add_ipv6_membership(
        &self,
        membership: &Ipv6MulticastMembership,
    ) -> Self::AddIpv6MembershipResponseFut;
    type DropIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>>
        + Send;
    fn r#drop_ipv6_membership(
        &self,
        membership: &Ipv6MulticastMembership,
    ) -> Self::DropIpv6MembershipResponseFut;
    type SetIpv6MulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_multicast_interface(
        &self,
        value: u64,
    ) -> Self::SetIpv6MulticastInterfaceResponseFut;
    type GetIpv6MulticastInterfaceResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut;
    type SetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>>
        + Send;
    fn r#set_ipv6_unicast_hops(&self, value: &OptionalUint8)
    -> Self::SetIpv6UnicastHopsResponseFut;
    type GetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>>
        + Send;
    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut;
    type SetIpv6ReceiveHopLimitResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_receive_hop_limit(&self, value: bool) -> Self::SetIpv6ReceiveHopLimitResponseFut;
    type GetIpv6ReceiveHopLimitResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut;
    type SetIpv6MulticastHopsResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_multicast_hops(
        &self,
        value: &OptionalUint8,
    ) -> Self::SetIpv6MulticastHopsResponseFut;
    type GetIpv6MulticastHopsResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut;
    type SetIpv6MulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_multicast_loopback(
        &self,
        value: bool,
    ) -> Self::SetIpv6MulticastLoopbackResponseFut;
    type GetIpv6MulticastLoopbackResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut;
    type SetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error>>
        + Send;
    fn r#set_ipv6_only(&self, value: bool) -> Self::SetIpv6OnlyResponseFut;
    type GetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error>>
        + Send;
    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut;
    type SetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_receive_traffic_class(
        &self,
        value: bool,
    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut;
    type GetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut;
    type SetIpv6TrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_traffic_class(
        &self,
        value: &OptionalUint8,
    ) -> Self::SetIpv6TrafficClassResponseFut;
    type GetIpv6TrafficClassResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut;
    type SetIpv6ReceivePacketInfoResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error>,
        > + Send;
    fn r#set_ipv6_receive_packet_info(
        &self,
        value: bool,
    ) -> Self::SetIpv6ReceivePacketInfoResponseFut;
    type GetIpv6ReceivePacketInfoResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error>,
        > + Send;
    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut;
    type GetOriginalDestinationResponseFut: std::future::Future<
            Output = Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error>,
        > + Send;
    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut;
    type GetInfoResponseFut: std::future::Future<Output = Result<BaseDatagramSocketGetInfoResult, fidl::Error>>
        + Send;
    fn r#get_info(&self) -> Self::GetInfoResponseFut;
    type DescribeResponseFut: std::future::Future<Output = Result<SynchronousDatagramSocketDescribeResponse, fidl::Error>>
        + Send;
    fn r#describe(&self) -> Self::DescribeResponseFut;
    type RecvMsgResponseFut: std::future::Future<Output = Result<SynchronousDatagramSocketRecvMsgResult, fidl::Error>>
        + Send;
    fn r#recv_msg(
        &self,
        want_addr: bool,
        data_len: u32,
        want_control: bool,
        flags: RecvMsgFlags,
    ) -> Self::RecvMsgResponseFut;
    type SendMsgResponseFut: std::future::Future<Output = Result<SynchronousDatagramSocketSendMsgResult, fidl::Error>>
        + Send;
    fn r#send_msg(
        &self,
        addr: Option<&fidl_fuchsia_net::SocketAddress>,
        data: &[u8],
        control: &DatagramSocketSendControlData,
        flags: SendMsgFlags,
    ) -> Self::SendMsgResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct SynchronousDatagramSocketSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for SynchronousDatagramSocketSynchronousProxy {
    type Proxy = SynchronousDatagramSocketProxy;
    type Protocol = SynchronousDatagramSocketMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl SynchronousDatagramSocketSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <SynchronousDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<SynchronousDatagramSocketEvent, fidl::Error> {
        SynchronousDatagramSocketEvent::decode(self.client.wait_for_event(deadline)?)
    }

    pub fn r#clone(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
        let _response = self.client.send_query::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_unknown::QueryableQueryResponse,
        >(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.protocol)
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#set_reuse_address(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetReuseAddressRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x1fd74ee8b9a4a876,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#get_reuse_address(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetReuseAddressResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Get `SOL_SOCKET` -> `SO_ERROR`.
    /// Returns the last error if there is an error set on the socket.
    pub fn r#get_error(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x5aad39b33e5f6ebb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#set_broadcast(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetBroadcastRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x6023e081ce3cd947,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#get_broadcast(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetBroadcastResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x68796fc556f9780d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#set_send_buffer(
        &self,
        mut value_bytes: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetSendBufferRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value_bytes,),
                0x756eac32d73a7a70,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#get_send_buffer(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetSendBufferResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value_bytes))
    }

    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#set_receive_buffer(
        &self,
        mut value_bytes: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseSocketSetReceiveBufferRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value_bytes,),
                    0x6b0cf2f1919c7001,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#get_receive_buffer(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetReceiveBufferResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value_bytes))
    }

    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#set_keep_alive(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetKeepAliveRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x572df8f0b920d2c7,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#get_keep_alive(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetKeepAliveResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x2dd29d3215f2c9d2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#set_out_of_band_inline(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseSocketSetOutOfBandInlineRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x3ecb49968bee439,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#get_out_of_band_inline(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetOutOfBandInlineResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#set_no_check(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetNoCheckRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x6bbf00c53a4c78c2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#get_no_check(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetNoCheckResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x2cd4249286417694,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#set_linger(
        &self,
        mut linger: bool,
        mut length_secs: u32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetLingerRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (linger, length_secs),
                0x45386351246e998e,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#get_linger(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetLingerResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x48eb20fc5ccb0e45,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| (x.linger, x.length_secs)))
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#set_reuse_port(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetReusePortRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x24dd3e5cb36d9ccb,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#get_reuse_port(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetReusePortResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x7a112c1ab54ff828,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
    pub fn r#get_accept_conn(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetAcceptConnResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#set_bind_to_device(
        &self,
        mut value: &str,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetBindToDeviceRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x2118b483f28aafc4,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#get_bind_to_device(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetBindToDeviceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    /// If `value` is 0, this clears the bound interface.
    pub fn r#set_bind_to_interface_index(
        &self,
        mut value: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x6e387a0def00821,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    pub fn r#get_bind_to_interface_index(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetBindToInterfaceIndexResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#set_timestamp(
        &self,
        mut value: TimestampOption,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetTimestampRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x285d6516c263d839,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#get_timestamp(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetTimestampResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x49f2fffbbcc2bd27,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be set independently in each domain.
    pub fn r#set_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        mut mark: &OptionalUint32,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketSetMarkRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (domain, mark),
                0x6ead6de09f653236,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be retrieved independently in each domain.
    pub fn r#get_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseSocketGetMarkRequest, fidl::encoding::ResultType<
                BaseSocketGetMarkResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (domain,),
                0x57a2752c61d93d47,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.mark))
    }

    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
    pub fn r#get_cookie(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseSocketGetCookieResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseSocketGetCookieResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x2c2f47fd8f924e52,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Sets the local address used for the socket.
    pub fn r#bind(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketBindRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (addr,),
                0x4bc6400ae92125d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Initiates a connection to a remote address.
    pub fn r#connect(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketConnectRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (addr,),
                0x5f05f19bfdd38871,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Clears connection information from this socket.
    pub fn r#disconnect(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (),
                0x74e63b91f7b29b2,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Retrieves the local socket address.
    pub fn r#get_sock_name(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetSockNameResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x475f23f84a1a4f85, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.addr))
    }

    /// Retrieves the remote socket address.
    pub fn r#get_peer_name(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetPeerNameResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x1ffecf4bd5b6432e, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.addr))
    }

    /// Shuts down part of the socket.
    pub fn r#shutdown(
        &self,
        mut mode: ShutdownMode,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketShutdownRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (mode,),
                0x247f38b6db68c336,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IP` -> `IP_TOS`.
    pub fn r#set_ip_type_of_service(
        &self,
        mut value: u8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpTypeOfServiceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x995c600475b6d46,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_TOS`.
    pub fn r#get_ip_type_of_service(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpTypeOfServiceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x3814a04259f75fcb, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_TTL`.
    pub fn r#set_ip_ttl(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
        let _response =
            self.client.send_query::<BaseNetworkSocketSetIpTtlRequest, fidl::encoding::ResultType<
                fidl::encoding::EmptyStruct,
                fidl_fuchsia_posix::Errno,
            >>(
                (value,),
                0x29e2424b433ae1ef,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_TTL`.
    pub fn r#get_ip_ttl(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpTtlResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x47e47fa1f24da471, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#set_ip_packet_info(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x392d16bee20c0e16,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#get_ip_packet_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpPacketInfoResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x54b505f242280740, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#set_ip_receive_type_of_service(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x6c4f6714995f84ef,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#get_ip_receive_type_of_service(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4158ba7dc2795960, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#set_ip_receive_ttl(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x46f15be0ce0ab82b,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#get_ip_receive_ttl(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpReceiveTtlResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x678ddd5a5dfa2eb5, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#set_ip_multicast_interface(
        &self,
        mut iface: u64,
        mut address: &fidl_fuchsia_net::Ipv4Address,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpMulticastInterfaceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (iface, address,),
            0x752fbfa9b12befe,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#get_ip_multicast_interface(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpMulticastInterfaceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x320bd14c4df046c4, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#set_ip_multicast_ttl(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x63134d53772916a1,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#get_ip_multicast_ttl(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpMulticastTtlResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4665cd378f39e1a, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#set_ip_multicast_loopback(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpMulticastLoopbackRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x20c55c11f00943ea,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#get_ip_multicast_loopback(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpMulticastLoopbackResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x3b6b26ff558298f2, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
    pub fn r#add_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (membership,),
                    0x76bc7df115a3b4d0,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
    pub fn r#drop_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (membership,),
                    0x2888f3099188d03,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#set_ip_transparent(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x1ae532b0c066e3a0,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#get_ip_transparent(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpTransparentResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x51d43695962ebfb5, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#set_ip_receive_original_destination_address(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x4722b4ce52f7840,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#get_ip_receive_original_destination_address(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x2a0e7dc5d6bfdfe9, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
    pub fn r#add_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (membership,),
                    0x7c94727acb4ea4b3,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
    pub fn r#drop_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketDropIpv6MembershipRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (membership,),
            0x42104c70ccaba304,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#set_ipv6_multicast_interface(
        &self,
        mut value: u64,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x135f76db3774ab3b,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#get_ipv6_multicast_interface(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x1f26fcdd348f1882, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#set_ipv6_unicast_hops(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6UnicastHopsRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x157d51e98f462859,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#get_ipv6_unicast_hops(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6UnicastHopsResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x21f4641cad8bd8d2, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#set_ipv6_receive_hop_limit(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x5c24808ed2e84a1e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#get_ipv6_receive_hop_limit(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x341e06689885b4c0, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#set_ipv6_multicast_hops(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6MulticastHopsRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x25b9cd4d181f82c1,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#get_ipv6_multicast_hops(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6MulticastHopsResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x52916948a365012a, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#set_ipv6_multicast_loopback(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x55701c409ff41b40,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#get_ipv6_multicast_loopback(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4415b701fde319c3, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#set_ipv6_only(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    fidl_fuchsia_posix::Errno,
                >>(
                    (value,),
                    0x4873f1364758cbba,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#get_ipv6_only(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6OnlyResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x4aa3340a1a26b89c, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#set_ipv6_receive_traffic_class(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x58f07c8788d099a0,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#get_ipv6_receive_traffic_class(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x2e334df1da553ffa, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
    pub fn r#set_ipv6_traffic_class(
        &self,
        mut value: &OptionalUint8,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6TrafficClassRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x6af077800c5a0b4f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
    pub fn r#get_ipv6_traffic_class(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6TrafficClassResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x6baf6eed8fc2f04, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#set_ipv6_receive_packet_info(
        &self,
        mut value: bool,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
        let _response = self.client.send_query::<
            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
        >(
            (value,),
            0x19259775b1a92768,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#get_ipv6_receive_packet_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x7acd4a2775baec75, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
    pub fn r#get_original_destination(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseNetworkSocketGetOriginalDestinationResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x38bf28f0dafdbac0, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| x.value))
    }

    /// Retrieves creation information from the socket.
    ///
    /// - response `domain` the socket's associated domain.
    /// - response `proto` the socket's associated protocol.
    pub fn r#get_info(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<BaseDatagramSocketGetInfoResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                BaseDatagramSocketGetInfoResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (), 0x48aa0a1f6a32d2ed, fidl::encoding::DynamicFlags::empty(), ___deadline
            )?;
        Ok(_response.map(|x| (x.domain, x.proto)))
    }

    pub fn r#describe(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SynchronousDatagramSocketDescribeResponse, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, SynchronousDatagramSocketDescribeResponse>(
                (),
                0x585f20b73631070d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Receives a message from the socket.
    ///
    /// + request `want_addr` request message's source address information to
    ///   be returned.
    /// + request `data_len` the maximum allowed length of the response data
    ///   buffer.
    /// + request `want_control` request ancillary data to be returned.
    /// + request `flags` flags for the receive request.
    /// - response `addr` the message's source address information, if
    ///   requested.
    /// - response `data` the message.
    /// - response `control` control messages, if requested.
    /// - response `truncated` indicates whether or not the returned message
    ///   was truncated.
    pub fn r#recv_msg(
        &self,
        mut want_addr: bool,
        mut data_len: u32,
        mut want_control: bool,
        mut flags: RecvMsgFlags,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SynchronousDatagramSocketRecvMsgResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<SynchronousDatagramSocketRecvMsgRequest, fidl::encoding::ResultType<
                SynchronousDatagramSocketRecvMsgResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (want_addr, data_len, want_control, flags),
                0x28e494e48fb5dbf3,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| (x.addr, x.data, x.control, x.truncated)))
    }

    /// Sends a message on the socket.
    ///
    /// + request `addr` the address to send the message to. If unset, will send
    ///   to the connected peer.
    /// + request `data` the message.
    /// + request `control` ancillary data.
    /// + request `flags` flags for the send request.
    /// - response `len` the number of bytes sent.
    pub fn r#send_msg(
        &self,
        mut addr: Option<&fidl_fuchsia_net::SocketAddress>,
        mut data: &[u8],
        mut control: &DatagramSocketSendControlData,
        mut flags: SendMsgFlags,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<SynchronousDatagramSocketSendMsgResult, fidl::Error> {
        let _response = self
            .client
            .send_query::<SynchronousDatagramSocketSendMsgRequest, fidl::encoding::ResultType<
                SynchronousDatagramSocketSendMsgResponse,
                fidl_fuchsia_posix::Errno,
            >>(
                (addr, data, control, flags),
                0x12dc2fceab6cefaa,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.len))
    }
}

#[cfg(target_os = "fuchsia")]
impl From<SynchronousDatagramSocketSynchronousProxy> for zx::Handle {
    fn from(value: SynchronousDatagramSocketSynchronousProxy) -> Self {
        value.into_channel().into()
    }
}

#[cfg(target_os = "fuchsia")]
impl From<fidl::Channel> for SynchronousDatagramSocketSynchronousProxy {
    fn from(value: fidl::Channel) -> Self {
        Self::new(value)
    }
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::FromClient for SynchronousDatagramSocketSynchronousProxy {
    type Protocol = SynchronousDatagramSocketMarker;

    fn from_client(value: fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>) -> Self {
        Self::new(value.into_channel())
    }
}

#[derive(Debug, Clone)]
pub struct SynchronousDatagramSocketProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for SynchronousDatagramSocketProxy {
    type Protocol = SynchronousDatagramSocketMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl SynchronousDatagramSocketProxy {
    /// Create a new Proxy for fuchsia.posix.socket/SynchronousDatagramSocket.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <SynchronousDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> SynchronousDatagramSocketEventStream {
        SynchronousDatagramSocketEventStream { event_receiver: self.client.take_event_receiver() }
    }

    pub fn r#clone(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        SynchronousDatagramSocketProxyInterface::r#clone(self, request)
    }

    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    pub fn r#close(
        &self,
    ) -> fidl::client::QueryResponseFut<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#close(self)
    }

    pub fn r#query(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        SynchronousDatagramSocketProxyInterface::r#query(self)
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#set_reuse_address(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_reuse_address(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
    pub fn r#get_reuse_address(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_reuse_address(self)
    }

    /// Get `SOL_SOCKET` -> `SO_ERROR`.
    /// Returns the last error if there is an error set on the socket.
    pub fn r#get_error(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetErrorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_error(self)
    }

    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#set_broadcast(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_broadcast(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
    pub fn r#get_broadcast(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_broadcast(self)
    }

    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#set_send_buffer(
        &self,
        mut value_bytes: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_send_buffer(self, value_bytes)
    }

    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
    pub fn r#get_send_buffer(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_send_buffer(self)
    }

    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#set_receive_buffer(
        &self,
        mut value_bytes: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_receive_buffer(self, value_bytes)
    }

    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
    pub fn r#get_receive_buffer(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_receive_buffer(self)
    }

    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#set_keep_alive(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_keep_alive(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
    pub fn r#get_keep_alive(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_keep_alive(self)
    }

    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#set_out_of_band_inline(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_out_of_band_inline(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
    pub fn r#get_out_of_band_inline(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_out_of_band_inline(self)
    }

    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#set_no_check(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_no_check(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
    pub fn r#get_no_check(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_no_check(self)
    }

    /// Set `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#set_linger(
        &self,
        mut linger: bool,
        mut length_secs: u32,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_linger(self, linger, length_secs)
    }

    /// Get `SOL_SOCKET` -> `SO_LINGER`.
    pub fn r#get_linger(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_linger(self)
    }

    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#set_reuse_port(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_reuse_port(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
    pub fn r#get_reuse_port(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_reuse_port(self)
    }

    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
    pub fn r#get_accept_conn(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetAcceptConnResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_accept_conn(self)
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#set_bind_to_device(
        &self,
        mut value: &str,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_bind_to_device(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    pub fn r#get_bind_to_device(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_bind_to_device(self)
    }

    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    /// If `value` is 0, this clears the bound interface.
    pub fn r#set_bind_to_interface_index(
        &self,
        mut value: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_bind_to_interface_index(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    pub fn r#get_bind_to_interface_index(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_bind_to_interface_index(self)
    }

    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#set_timestamp(
        &self,
        mut value: TimestampOption,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_timestamp(self, value)
    }

    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    pub fn r#get_timestamp(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_timestamp(self)
    }

    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be set independently in each domain.
    pub fn r#set_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        mut mark: &OptionalUint32,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketSetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_mark(self, domain, mark)
    }

    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be retrieved independently in each domain.
    pub fn r#get_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_mark(self, domain)
    }

    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
    pub fn r#get_cookie(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseSocketGetCookieResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_cookie(self)
    }

    /// Sets the local address used for the socket.
    pub fn r#bind(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketBindResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#bind(self, addr)
    }

    /// Initiates a connection to a remote address.
    pub fn r#connect(
        &self,
        mut addr: &fidl_fuchsia_net::SocketAddress,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#connect(self, addr)
    }

    /// Clears connection information from this socket.
    pub fn r#disconnect(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketDisconnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#disconnect(self)
    }

    /// Retrieves the local socket address.
    pub fn r#get_sock_name(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetSockNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_sock_name(self)
    }

    /// Retrieves the remote socket address.
    pub fn r#get_peer_name(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetPeerNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_peer_name(self)
    }

    /// Shuts down part of the socket.
    pub fn r#shutdown(
        &self,
        mut mode: ShutdownMode,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketShutdownResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#shutdown(self, mode)
    }

    /// Set `SOL_IP` -> `IP_TOS`.
    pub fn r#set_ip_type_of_service(
        &self,
        mut value: u8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ip_type_of_service(self, value)
    }

    /// Get `SOL_IP` -> `IP_TOS`.
    pub fn r#get_ip_type_of_service(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ip_type_of_service(self)
    }

    /// Set `SOL_IP` -> `IP_TTL`.
    pub fn r#set_ip_ttl(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ip_ttl(self, value)
    }

    /// Get `SOL_IP` -> `IP_TTL`.
    pub fn r#get_ip_ttl(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ip_ttl(self)
    }

    /// Set `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#set_ip_packet_info(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ip_packet_info(self, value)
    }

    /// Get `SOL_IP` -> `IP_PKTINFO`.
    pub fn r#get_ip_packet_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ip_packet_info(self)
    }

    /// Set `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#set_ip_receive_type_of_service(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ip_receive_type_of_service(self, value)
    }

    /// Get `SOL_IP` -> `IP_RECVTOS`.
    pub fn r#get_ip_receive_type_of_service(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ip_receive_type_of_service(self)
    }

    /// Set `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#set_ip_receive_ttl(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ip_receive_ttl(self, value)
    }

    /// Get `SOL_IP` -> `IP_RECVTTL`.
    pub fn r#get_ip_receive_ttl(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ip_receive_ttl(self)
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#set_ip_multicast_interface(
        &self,
        mut iface: u64,
        mut address: &fidl_fuchsia_net::Ipv4Address,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ip_multicast_interface(self, iface, address)
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
    pub fn r#get_ip_multicast_interface(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ip_multicast_interface(self)
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#set_ip_multicast_ttl(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ip_multicast_ttl(self, value)
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
    pub fn r#get_ip_multicast_ttl(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ip_multicast_ttl(self)
    }

    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#set_ip_multicast_loopback(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ip_multicast_loopback(self, value)
    }

    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
    pub fn r#get_ip_multicast_loopback(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ip_multicast_loopback(self)
    }

    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
    pub fn r#add_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#add_ip_membership(self, membership)
    }

    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
    pub fn r#drop_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#drop_ip_membership(self, membership)
    }

    /// Set `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#set_ip_transparent(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ip_transparent(self, value)
    }

    /// Get `SOL_IP` -> `IP_TRANSPARENT`
    pub fn r#get_ip_transparent(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ip_transparent(self)
    }

    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#set_ip_receive_original_destination_address(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ip_receive_original_destination_address(
            self, value,
        )
    }

    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
    pub fn r#get_ip_receive_original_destination_address(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ip_receive_original_destination_address(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
    pub fn r#add_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#add_ipv6_membership(self, membership)
    }

    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
    pub fn r#drop_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#drop_ipv6_membership(self, membership)
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#set_ipv6_multicast_interface(
        &self,
        mut value: u64,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ipv6_multicast_interface(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    pub fn r#get_ipv6_multicast_interface(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ipv6_multicast_interface(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#set_ipv6_unicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ipv6_unicast_hops(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    pub fn r#get_ipv6_unicast_hops(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ipv6_unicast_hops(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#set_ipv6_receive_hop_limit(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ipv6_receive_hop_limit(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    pub fn r#get_ipv6_receive_hop_limit(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ipv6_receive_hop_limit(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#set_ipv6_multicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ipv6_multicast_hops(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    pub fn r#get_ipv6_multicast_hops(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ipv6_multicast_hops(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#set_ipv6_multicast_loopback(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ipv6_multicast_loopback(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    pub fn r#get_ipv6_multicast_loopback(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ipv6_multicast_loopback(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#set_ipv6_only(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ipv6_only(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
    pub fn r#get_ipv6_only(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ipv6_only(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#set_ipv6_receive_traffic_class(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ipv6_receive_traffic_class(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    pub fn r#get_ipv6_receive_traffic_class(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ipv6_receive_traffic_class(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
    pub fn r#set_ipv6_traffic_class(
        &self,
        mut value: &OptionalUint8,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ipv6_traffic_class(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
    pub fn r#get_ipv6_traffic_class(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ipv6_traffic_class(self)
    }

    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#set_ipv6_receive_packet_info(
        &self,
        mut value: bool,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#set_ipv6_receive_packet_info(self, value)
    }

    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    pub fn r#get_ipv6_receive_packet_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_ipv6_receive_packet_info(self)
    }

    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
    pub fn r#get_original_destination(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseNetworkSocketGetOriginalDestinationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_original_destination(self)
    }

    /// Retrieves creation information from the socket.
    ///
    /// - response `domain` the socket's associated domain.
    /// - response `proto` the socket's associated protocol.
    pub fn r#get_info(
        &self,
    ) -> fidl::client::QueryResponseFut<
        BaseDatagramSocketGetInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#get_info(self)
    }

    pub fn r#describe(
        &self,
    ) -> fidl::client::QueryResponseFut<
        SynchronousDatagramSocketDescribeResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#describe(self)
    }

    /// Receives a message from the socket.
    ///
    /// + request `want_addr` request message's source address information to
    ///   be returned.
    /// + request `data_len` the maximum allowed length of the response data
    ///   buffer.
    /// + request `want_control` request ancillary data to be returned.
    /// + request `flags` flags for the receive request.
    /// - response `addr` the message's source address information, if
    ///   requested.
    /// - response `data` the message.
    /// - response `control` control messages, if requested.
    /// - response `truncated` indicates whether or not the returned message
    ///   was truncated.
    pub fn r#recv_msg(
        &self,
        mut want_addr: bool,
        mut data_len: u32,
        mut want_control: bool,
        mut flags: RecvMsgFlags,
    ) -> fidl::client::QueryResponseFut<
        SynchronousDatagramSocketRecvMsgResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#recv_msg(
            self,
            want_addr,
            data_len,
            want_control,
            flags,
        )
    }

    /// Sends a message on the socket.
    ///
    /// + request `addr` the address to send the message to. If unset, will send
    ///   to the connected peer.
    /// + request `data` the message.
    /// + request `control` ancillary data.
    /// + request `flags` flags for the send request.
    /// - response `len` the number of bytes sent.
    pub fn r#send_msg(
        &self,
        mut addr: Option<&fidl_fuchsia_net::SocketAddress>,
        mut data: &[u8],
        mut control: &DatagramSocketSendControlData,
        mut flags: SendMsgFlags,
    ) -> fidl::client::QueryResponseFut<
        SynchronousDatagramSocketSendMsgResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        SynchronousDatagramSocketProxyInterface::r#send_msg(self, addr, data, control, flags)
    }
}

impl SynchronousDatagramSocketProxyInterface for SynchronousDatagramSocketProxy {
    fn r#clone(
        &self,
        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
            (request,),
            0x20d8a7aba2168a79,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type CloseResponseFut = fidl::client::QueryResponseFut<
        fidl_fuchsia_unknown::CloseableCloseResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#close(&self) -> Self::CloseResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5ac5d459ad7f657e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            fidl_fuchsia_unknown::CloseableCloseResult,
        >(
            (),
            0x5ac5d459ad7f657e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type QueryResponseFut =
        fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#query(&self) -> Self::QueryResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<u8>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl_fuchsia_unknown::QueryableQueryResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2658edee9decfc06,
            >(_buf?)?;
            Ok(_response.protocol)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
            (),
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1fd74ee8b9a4a876,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetReuseAddressRequest,
            BaseSocketSetReuseAddressResult,
        >(
            (value,),
            0x1fd74ee8b9a4a876,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetReuseAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetReuseAddressResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x67b7206b8d1bc0a5,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReuseAddressResult>(
                (),
                0x67b7206b8d1bc0a5,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetErrorResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetErrorResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_error(&self) -> Self::GetErrorResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5aad39b33e5f6ebb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetErrorResult>(
            (),
            0x5aad39b33e5f6ebb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6023e081ce3cd947,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetBroadcastRequest, BaseSocketSetBroadcastResult>(
                (value,),
                0x6023e081ce3cd947,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetBroadcastResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetBroadcastResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x68796fc556f9780d,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBroadcastResult>(
                (),
                0x68796fc556f9780d,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x756eac32d73a7a70,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetSendBufferRequest, BaseSocketSetSendBufferResult>(
                (value_bytes,),
                0x756eac32d73a7a70,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetSendBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetSendBufferResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x78a52fd9c7b2410b,
            >(_buf?)?;
            Ok(_response.map(|x| x.value_bytes))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetSendBufferResult>(
                (),
                0x78a52fd9c7b2410b,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6b0cf2f1919c7001,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetReceiveBufferRequest,
            BaseSocketSetReceiveBufferResult,
        >(
            (value_bytes,),
            0x6b0cf2f1919c7001,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetReceiveBufferResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetReceiveBufferResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x14c1a4b64f709e5c,
            >(_buf?)?;
            Ok(_response.map(|x| x.value_bytes))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseSocketGetReceiveBufferResult,
        >(
            (),
            0x14c1a4b64f709e5c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x572df8f0b920d2c7,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetKeepAliveRequest, BaseSocketSetKeepAliveResult>(
                (value,),
                0x572df8f0b920d2c7,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetKeepAliveResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetKeepAliveResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2dd29d3215f2c9d2,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetKeepAliveResult>(
                (),
                0x2dd29d3215f2c9d2,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3ecb49968bee439,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetOutOfBandInlineRequest,
            BaseSocketSetOutOfBandInlineResult,
        >(
            (value,),
            0x3ecb49968bee439,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetOutOfBandInlineResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetOutOfBandInlineResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x348c1ab3aeca1745,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseSocketGetOutOfBandInlineResult,
        >(
            (),
            0x348c1ab3aeca1745,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6bbf00c53a4c78c2,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetNoCheckRequest, BaseSocketSetNoCheckResult>(
                (value,),
                0x6bbf00c53a4c78c2,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetNoCheckResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetNoCheckResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2cd4249286417694,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetNoCheckResult>(
                (),
                0x2cd4249286417694,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetLingerResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x45386351246e998e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<BaseSocketSetLingerRequest, BaseSocketSetLingerResult>(
            (linger, length_secs),
            0x45386351246e998e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetLingerResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetLingerResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_linger(&self) -> Self::GetLingerResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetLingerResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x48eb20fc5ccb0e45,
            >(_buf?)?;
            Ok(_response.map(|x| (x.linger, x.length_secs)))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetLingerResult>(
                (),
                0x48eb20fc5ccb0e45,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetReusePortResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x24dd3e5cb36d9ccb,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetReusePortRequest, BaseSocketSetReusePortResult>(
                (value,),
                0x24dd3e5cb36d9ccb,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetReusePortResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetReusePortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetReusePortResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7a112c1ab54ff828,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReusePortResult>(
                (),
                0x7a112c1ab54ff828,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetAcceptConnResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetAcceptConnResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x67ce6db6c2ec8966,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetAcceptConnResult>(
                (),
                0x67ce6db6c2ec8966,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2118b483f28aafc4,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetBindToDeviceRequest,
            BaseSocketSetBindToDeviceResult,
        >(
            (value,),
            0x2118b483f28aafc4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetBindToDeviceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetBindToDeviceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ab1fbf0ef7906c8,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBindToDeviceResult>(
                (),
                0x1ab1fbf0ef7906c8,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_bind_to_interface_index(
        &self,
        mut value: u64,
    ) -> Self::SetBindToInterfaceIndexResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6e387a0def00821,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseSocketSetBindToInterfaceIndexRequest,
            BaseSocketSetBindToInterfaceIndexResult,
        >(
            (value,),
            0x6e387a0def00821,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetBindToInterfaceIndexResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetBindToInterfaceIndexResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x59c31dd3e3078295,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseSocketGetBindToInterfaceIndexResult,
        >(
            (),
            0x59c31dd3e3078295,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetTimestampResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_timestamp(&self, mut value: TimestampOption) -> Self::SetTimestampResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x285d6516c263d839,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseSocketSetTimestampRequest, BaseSocketSetTimestampResult>(
                (value,),
                0x285d6516c263d839,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type GetTimestampResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetTimestampResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseSocketGetTimestampResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x49f2fffbbcc2bd27,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetTimestampResult>(
                (),
                0x49f2fffbbcc2bd27,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetMarkResponseFut = fidl::client::QueryResponseFut<
        BaseSocketSetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_mark(
        &self,
        mut domain: fidl_fuchsia_net::MarkDomain,
        mut mark: &OptionalUint32,
    ) -> Self::SetMarkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6ead6de09f653236,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<BaseSocketSetMarkRequest, BaseSocketSetMarkResult>(
            (domain, mark),
            0x6ead6de09f653236,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetMarkResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetMarkResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x57a2752c61d93d47,
            >(_buf?)?;
            Ok(_response.map(|x| x.mark))
        }
        self.client.send_query_and_decode::<BaseSocketGetMarkRequest, BaseSocketGetMarkResult>(
            (domain,),
            0x57a2752c61d93d47,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetCookieResponseFut = fidl::client::QueryResponseFut<
        BaseSocketGetCookieResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_cookie(&self) -> Self::GetCookieResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseSocketGetCookieResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<BaseSocketGetCookieResponse, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2c2f47fd8f924e52,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetCookieResult>(
                (),
                0x2c2f47fd8f924e52,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type BindResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketBindResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#bind(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4bc6400ae92125d,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<BaseNetworkSocketBindRequest, BaseNetworkSocketBindResult>(
                (addr,),
                0x4bc6400ae92125d,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ConnectResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketConnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#connect(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5f05f19bfdd38871,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketConnectRequest,
            BaseNetworkSocketConnectResult,
        >(
            (addr,),
            0x5f05f19bfdd38871,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DisconnectResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketDisconnectResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#disconnect(&self) -> Self::DisconnectResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x74e63b91f7b29b2,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketDisconnectResult,
        >(
            (),
            0x74e63b91f7b29b2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetSockNameResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetSockNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetSockNameResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x475f23f84a1a4f85,
            >(_buf?)?;
            Ok(_response.map(|x| x.addr))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetSockNameResult,
        >(
            (),
            0x475f23f84a1a4f85,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetPeerNameResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetPeerNameResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetPeerNameResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ffecf4bd5b6432e,
            >(_buf?)?;
            Ok(_response.map(|x| x.addr))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetPeerNameResult,
        >(
            (),
            0x1ffecf4bd5b6432e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type ShutdownResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketShutdownResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#shutdown(&self, mut mode: ShutdownMode) -> Self::ShutdownResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x247f38b6db68c336,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketShutdownRequest,
            BaseNetworkSocketShutdownResult,
        >(
            (mode,),
            0x247f38b6db68c336,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_type_of_service(&self, mut value: u8) -> Self::SetIpTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x995c600475b6d46,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpTypeOfServiceRequest,
            BaseNetworkSocketSetIpTypeOfServiceResult,
        >(
            (value,),
            0x995c600475b6d46,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpTypeOfServiceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3814a04259f75fcb,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpTypeOfServiceResult,
        >(
            (),
            0x3814a04259f75fcb,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_ttl(&self, mut value: &OptionalUint8) -> Self::SetIpTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x29e2424b433ae1ef,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpTtlRequest,
            BaseNetworkSocketSetIpTtlResult,
        >(
            (value,),
            0x29e2424b433ae1ef,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpTtlResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x47e47fa1f24da471,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseNetworkSocketGetIpTtlResult>(
                (),
                0x47e47fa1f24da471,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type SetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_packet_info(&self, mut value: bool) -> Self::SetIpPacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x392d16bee20c0e16,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpPacketInfoRequest,
            BaseNetworkSocketSetIpPacketInfoResult,
        >(
            (value,),
            0x392d16bee20c0e16,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpPacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpPacketInfoResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x54b505f242280740,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpPacketInfoResult,
        >(
            (),
            0x54b505f242280740,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_receive_type_of_service(
        &self,
        mut value: bool,
    ) -> Self::SetIpReceiveTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6c4f6714995f84ef,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
            BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
        >(
            (value,),
            0x6c4f6714995f84ef,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4158ba7dc2795960,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
        >(
            (),
            0x4158ba7dc2795960,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_receive_ttl(&self, mut value: bool) -> Self::SetIpReceiveTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x46f15be0ce0ab82b,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpReceiveTtlRequest,
            BaseNetworkSocketSetIpReceiveTtlResult,
        >(
            (value,),
            0x46f15be0ce0ab82b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpReceiveTtlResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x678ddd5a5dfa2eb5,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpReceiveTtlResult,
        >(
            (),
            0x678ddd5a5dfa2eb5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_multicast_interface(
        &self,
        mut iface: u64,
        mut address: &fidl_fuchsia_net::Ipv4Address,
    ) -> Self::SetIpMulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x752fbfa9b12befe,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpMulticastInterfaceRequest,
            BaseNetworkSocketSetIpMulticastInterfaceResult,
        >(
            (iface, address,),
            0x752fbfa9b12befe,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpMulticastInterfaceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x320bd14c4df046c4,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpMulticastInterfaceResult,
        >(
            (),
            0x320bd14c4df046c4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_multicast_ttl(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpMulticastTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x63134d53772916a1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpMulticastTtlRequest,
            BaseNetworkSocketSetIpMulticastTtlResult,
        >(
            (value,),
            0x63134d53772916a1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastTtlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpMulticastTtlResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4665cd378f39e1a,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpMulticastTtlResult,
        >(
            (),
            0x4665cd378f39e1a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_multicast_loopback(
        &self,
        mut value: bool,
    ) -> Self::SetIpMulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x20c55c11f00943ea,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpMulticastLoopbackRequest,
            BaseNetworkSocketSetIpMulticastLoopbackResult,
        >(
            (value,),
            0x20c55c11f00943ea,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpMulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpMulticastLoopbackResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x3b6b26ff558298f2,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpMulticastLoopbackResult,
        >(
            (),
            0x3b6b26ff558298f2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddIpMembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> Self::AddIpMembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x76bc7df115a3b4d0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketAddIpMembershipRequest,
            BaseNetworkSocketAddIpMembershipResult,
        >(
            (membership,),
            0x76bc7df115a3b4d0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DropIpMembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpMembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#drop_ip_membership(
        &self,
        mut membership: &IpMulticastMembership,
    ) -> Self::DropIpMembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2888f3099188d03,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketDropIpMembershipRequest,
            BaseNetworkSocketDropIpMembershipResult,
        >(
            (membership,),
            0x2888f3099188d03,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpTransparentResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_transparent(&self, mut value: bool) -> Self::SetIpTransparentResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1ae532b0c066e3a0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpTransparentRequest,
            BaseNetworkSocketSetIpTransparentResult,
        >(
            (value,),
            0x1ae532b0c066e3a0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpTransparentResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpTransparentResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpTransparentResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x51d43695962ebfb5,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpTransparentResult,
        >(
            (),
            0x51d43695962ebfb5,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ip_receive_original_destination_address(
        &self,
        mut value: bool,
    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4722b4ce52f7840,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
        >(
            (value,),
            0x4722b4ce52f7840,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ip_receive_original_destination_address(
        &self,
    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>
        {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2a0e7dc5d6bfdfe9,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
        >(
            (),
            0x2a0e7dc5d6bfdfe9,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketAddIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> Self::AddIpv6MembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7c94727acb4ea4b3,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketAddIpv6MembershipRequest,
            BaseNetworkSocketAddIpv6MembershipResult,
        >(
            (membership,),
            0x7c94727acb4ea4b3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type DropIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketDropIpv6MembershipResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#drop_ipv6_membership(
        &self,
        mut membership: &Ipv6MulticastMembership,
    ) -> Self::DropIpv6MembershipResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x42104c70ccaba304,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketDropIpv6MembershipRequest,
            BaseNetworkSocketDropIpv6MembershipResult,
        >(
            (membership,),
            0x42104c70ccaba304,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_multicast_interface(
        &self,
        mut value: u64,
    ) -> Self::SetIpv6MulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x135f76db3774ab3b,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
            BaseNetworkSocketSetIpv6MulticastInterfaceResult,
        >(
            (value,),
            0x135f76db3774ab3b,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x1f26fcdd348f1882,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6MulticastInterfaceResult,
        >(
            (),
            0x1f26fcdd348f1882,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_unicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpv6UnicastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x157d51e98f462859,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6UnicastHopsRequest,
            BaseNetworkSocketSetIpv6UnicastHopsResult,
        >(
            (value,),
            0x157d51e98f462859,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6UnicastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6UnicastHopsResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x21f4641cad8bd8d2,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6UnicastHopsResult,
        >(
            (),
            0x21f4641cad8bd8d2,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_receive_hop_limit(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6ReceiveHopLimitResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x5c24808ed2e84a1e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
            BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
        >(
            (value,),
            0x5c24808ed2e84a1e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x341e06689885b4c0,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
        >(
            (),
            0x341e06689885b4c0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_multicast_hops(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpv6MulticastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x25b9cd4d181f82c1,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6MulticastHopsRequest,
            BaseNetworkSocketSetIpv6MulticastHopsResult,
        >(
            (value,),
            0x25b9cd4d181f82c1,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastHopsResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6MulticastHopsResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x52916948a365012a,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6MulticastHopsResult,
        >(
            (),
            0x52916948a365012a,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_multicast_loopback(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6MulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x55701c409ff41b40,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
            BaseNetworkSocketSetIpv6MulticastLoopbackResult,
        >(
            (value,),
            0x55701c409ff41b40,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4415b701fde319c3,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6MulticastLoopbackResult,
        >(
            (),
            0x4415b701fde319c3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_only(&self, mut value: bool) -> Self::SetIpv6OnlyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4873f1364758cbba,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6OnlyRequest,
            BaseNetworkSocketSetIpv6OnlyResult,
        >(
            (value,),
            0x4873f1364758cbba,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6OnlyResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6OnlyResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4aa3340a1a26b89c,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6OnlyResult,
        >(
            (),
            0x4aa3340a1a26b89c,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_receive_traffic_class(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x58f07c8788d099a0,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
            BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
        >(
            (value,),
            0x58f07c8788d099a0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2e334df1da553ffa,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
        >(
            (),
            0x2e334df1da553ffa,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_traffic_class(
        &self,
        mut value: &OptionalUint8,
    ) -> Self::SetIpv6TrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6af077800c5a0b4f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6TrafficClassRequest,
            BaseNetworkSocketSetIpv6TrafficClassResult,
        >(
            (value,),
            0x6af077800c5a0b4f,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6TrafficClassResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6TrafficClassResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6baf6eed8fc2f04,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6TrafficClassResult,
        >(
            (),
            0x6baf6eed8fc2f04,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#set_ipv6_receive_packet_info(
        &self,
        mut value: bool,
    ) -> Self::SetIpv6ReceivePacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x19259775b1a92768,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
            BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
        >(
            (value,),
            0x19259775b1a92768,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x7acd4a2775baec75,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
        >(
            (),
            0x7acd4a2775baec75,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetOriginalDestinationResponseFut = fidl::client::QueryResponseFut<
        BaseNetworkSocketGetOriginalDestinationResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseNetworkSocketGetOriginalDestinationResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x38bf28f0dafdbac0,
            >(_buf?)?;
            Ok(_response.map(|x| x.value))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            BaseNetworkSocketGetOriginalDestinationResult,
        >(
            (),
            0x38bf28f0dafdbac0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type GetInfoResponseFut = fidl::client::QueryResponseFut<
        BaseDatagramSocketGetInfoResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_info(&self) -> Self::GetInfoResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<BaseDatagramSocketGetInfoResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    BaseDatagramSocketGetInfoResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x48aa0a1f6a32d2ed,
            >(_buf?)?;
            Ok(_response.map(|x| (x.domain, x.proto)))
        }
        self.client
            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseDatagramSocketGetInfoResult>(
                (),
                0x48aa0a1f6a32d2ed,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type DescribeResponseFut = fidl::client::QueryResponseFut<
        SynchronousDatagramSocketDescribeResponse,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#describe(&self) -> Self::DescribeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SynchronousDatagramSocketDescribeResponse, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                SynchronousDatagramSocketDescribeResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x585f20b73631070d,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            SynchronousDatagramSocketDescribeResponse,
        >(
            (),
            0x585f20b73631070d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type RecvMsgResponseFut = fidl::client::QueryResponseFut<
        SynchronousDatagramSocketRecvMsgResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#recv_msg(
        &self,
        mut want_addr: bool,
        mut data_len: u32,
        mut want_control: bool,
        mut flags: RecvMsgFlags,
    ) -> Self::RecvMsgResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SynchronousDatagramSocketRecvMsgResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    SynchronousDatagramSocketRecvMsgResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x28e494e48fb5dbf3,
            >(_buf?)?;
            Ok(_response.map(|x| (x.addr, x.data, x.control, x.truncated)))
        }
        self.client.send_query_and_decode::<
            SynchronousDatagramSocketRecvMsgRequest,
            SynchronousDatagramSocketRecvMsgResult,
        >(
            (want_addr, data_len, want_control, flags,),
            0x28e494e48fb5dbf3,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type SendMsgResponseFut = fidl::client::QueryResponseFut<
        SynchronousDatagramSocketSendMsgResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#send_msg(
        &self,
        mut addr: Option<&fidl_fuchsia_net::SocketAddress>,
        mut data: &[u8],
        mut control: &DatagramSocketSendControlData,
        mut flags: SendMsgFlags,
    ) -> Self::SendMsgResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<SynchronousDatagramSocketSendMsgResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<
                    SynchronousDatagramSocketSendMsgResponse,
                    fidl_fuchsia_posix::Errno,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x12dc2fceab6cefaa,
            >(_buf?)?;
            Ok(_response.map(|x| x.len))
        }
        self.client.send_query_and_decode::<
            SynchronousDatagramSocketSendMsgRequest,
            SynchronousDatagramSocketSendMsgResult,
        >(
            (addr, data, control, flags,),
            0x12dc2fceab6cefaa,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct SynchronousDatagramSocketEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for SynchronousDatagramSocketEventStream {}

impl futures::stream::FusedStream for SynchronousDatagramSocketEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for SynchronousDatagramSocketEventStream {
    type Item = Result<SynchronousDatagramSocketEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(SynchronousDatagramSocketEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum SynchronousDatagramSocketEvent {}

impl SynchronousDatagramSocketEvent {
    /// Decodes a message buffer as a [`SynchronousDatagramSocketEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<SynchronousDatagramSocketEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <SynchronousDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.posix.socket/SynchronousDatagramSocket.
pub struct SynchronousDatagramSocketRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for SynchronousDatagramSocketRequestStream {}

impl futures::stream::FusedStream for SynchronousDatagramSocketRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for SynchronousDatagramSocketRequestStream {
    type Protocol = SynchronousDatagramSocketMarker;
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        SynchronousDatagramSocketControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for SynchronousDatagramSocketRequestStream {
    type Item = Result<SynchronousDatagramSocketRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled SynchronousDatagramSocketRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))));
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                0x20d8a7aba2168a79 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(fidl_fuchsia_unknown::CloneableCloneRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::Clone {request: req.request,

                        control_handle,
                    })
                }
                0x5ac5d459ad7f657e => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::Close {
                        responder: SynchronousDatagramSocketCloseResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2658edee9decfc06 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::Query {
                        responder: SynchronousDatagramSocketQueryResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1fd74ee8b9a4a876 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetReuseAddressRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetReuseAddress {value: req.value,

                        responder: SynchronousDatagramSocketSetReuseAddressResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x67b7206b8d1bc0a5 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetReuseAddress {
                        responder: SynchronousDatagramSocketGetReuseAddressResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x5aad39b33e5f6ebb => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetError {
                        responder: SynchronousDatagramSocketGetErrorResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6023e081ce3cd947 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetBroadcastRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetBroadcast {value: req.value,

                        responder: SynchronousDatagramSocketSetBroadcastResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x68796fc556f9780d => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetBroadcast {
                        responder: SynchronousDatagramSocketGetBroadcastResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x756eac32d73a7a70 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetSendBufferRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetSendBuffer {value_bytes: req.value_bytes,

                        responder: SynchronousDatagramSocketSetSendBufferResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x78a52fd9c7b2410b => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetSendBuffer {
                        responder: SynchronousDatagramSocketGetSendBufferResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6b0cf2f1919c7001 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetReceiveBufferRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetReceiveBuffer {value_bytes: req.value_bytes,

                        responder: SynchronousDatagramSocketSetReceiveBufferResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x14c1a4b64f709e5c => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetReceiveBuffer {
                        responder: SynchronousDatagramSocketGetReceiveBufferResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x572df8f0b920d2c7 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetKeepAliveRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetKeepAlive {value: req.value,

                        responder: SynchronousDatagramSocketSetKeepAliveResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2dd29d3215f2c9d2 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetKeepAlive {
                        responder: SynchronousDatagramSocketGetKeepAliveResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x3ecb49968bee439 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetOutOfBandInlineRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetOutOfBandInline {value: req.value,

                        responder: SynchronousDatagramSocketSetOutOfBandInlineResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x348c1ab3aeca1745 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetOutOfBandInline {
                        responder: SynchronousDatagramSocketGetOutOfBandInlineResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6bbf00c53a4c78c2 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetNoCheckRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetNoCheck {value: req.value,

                        responder: SynchronousDatagramSocketSetNoCheckResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2cd4249286417694 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetNoCheck {
                        responder: SynchronousDatagramSocketGetNoCheckResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x45386351246e998e => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetLingerRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetLinger {linger: req.linger,
length_secs: req.length_secs,

                        responder: SynchronousDatagramSocketSetLingerResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x48eb20fc5ccb0e45 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetLinger {
                        responder: SynchronousDatagramSocketGetLingerResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x24dd3e5cb36d9ccb => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetReusePortRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetReusePort {value: req.value,

                        responder: SynchronousDatagramSocketSetReusePortResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x7a112c1ab54ff828 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetReusePort {
                        responder: SynchronousDatagramSocketGetReusePortResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x67ce6db6c2ec8966 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetAcceptConn {
                        responder: SynchronousDatagramSocketGetAcceptConnResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2118b483f28aafc4 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetBindToDeviceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetBindToDevice {value: req.value,

                        responder: SynchronousDatagramSocketSetBindToDeviceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1ab1fbf0ef7906c8 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetBindToDevice {
                        responder: SynchronousDatagramSocketGetBindToDeviceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6e387a0def00821 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetBindToInterfaceIndex {value: req.value,

                        responder: SynchronousDatagramSocketSetBindToInterfaceIndexResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x59c31dd3e3078295 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetBindToInterfaceIndex {
                        responder: SynchronousDatagramSocketGetBindToInterfaceIndexResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x285d6516c263d839 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetTimestampRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetTimestamp {value: req.value,

                        responder: SynchronousDatagramSocketSetTimestampResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x49f2fffbbcc2bd27 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetTimestamp {
                        responder: SynchronousDatagramSocketGetTimestampResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6ead6de09f653236 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketSetMarkRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetMark {domain: req.domain,
mark: req.mark,

                        responder: SynchronousDatagramSocketSetMarkResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x57a2752c61d93d47 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseSocketGetMarkRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetMark {domain: req.domain,

                        responder: SynchronousDatagramSocketGetMarkResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2c2f47fd8f924e52 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetCookie {
                        responder: SynchronousDatagramSocketGetCookieResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4bc6400ae92125d => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketBindRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketBindRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::Bind {addr: req.addr,

                        responder: SynchronousDatagramSocketBindResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x5f05f19bfdd38871 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketConnectRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::Connect {addr: req.addr,

                        responder: SynchronousDatagramSocketConnectResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x74e63b91f7b29b2 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::Disconnect {
                        responder: SynchronousDatagramSocketDisconnectResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x475f23f84a1a4f85 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetSockName {
                        responder: SynchronousDatagramSocketGetSockNameResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1ffecf4bd5b6432e => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetPeerName {
                        responder: SynchronousDatagramSocketGetPeerNameResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x247f38b6db68c336 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketShutdownRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketShutdownRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::Shutdown {mode: req.mode,

                        responder: SynchronousDatagramSocketShutdownResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x995c600475b6d46 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpTypeOfServiceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpTypeOfService {value: req.value,

                        responder: SynchronousDatagramSocketSetIpTypeOfServiceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x3814a04259f75fcb => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpTypeOfService {
                        responder: SynchronousDatagramSocketGetIpTypeOfServiceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x29e2424b433ae1ef => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpTtlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTtlRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpTtl {value: req.value,

                        responder: SynchronousDatagramSocketSetIpTtlResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x47e47fa1f24da471 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpTtl {
                        responder: SynchronousDatagramSocketGetIpTtlResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x392d16bee20c0e16 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpPacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpPacketInfo {value: req.value,

                        responder: SynchronousDatagramSocketSetIpPacketInfoResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x54b505f242280740 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpPacketInfo {
                        responder: SynchronousDatagramSocketGetIpPacketInfoResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6c4f6714995f84ef => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpReceiveTypeOfServiceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpReceiveTypeOfService {value: req.value,

                        responder: SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4158ba7dc2795960 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpReceiveTypeOfService {
                        responder: SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x46f15be0ce0ab82b => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTtlRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpReceiveTtl {value: req.value,

                        responder: SynchronousDatagramSocketSetIpReceiveTtlResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x678ddd5a5dfa2eb5 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpReceiveTtl {
                        responder: SynchronousDatagramSocketGetIpReceiveTtlResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x752fbfa9b12befe => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpMulticastInterfaceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpMulticastInterface {iface: req.iface,
address: req.address,

                        responder: SynchronousDatagramSocketSetIpMulticastInterfaceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x320bd14c4df046c4 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpMulticastInterface {
                        responder: SynchronousDatagramSocketGetIpMulticastInterfaceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x63134d53772916a1 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastTtlRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpMulticastTtl {value: req.value,

                        responder: SynchronousDatagramSocketSetIpMulticastTtlResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4665cd378f39e1a => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpMulticastTtl {
                        responder: SynchronousDatagramSocketGetIpMulticastTtlResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x20c55c11f00943ea => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpMulticastLoopbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpMulticastLoopback {value: req.value,

                        responder: SynchronousDatagramSocketSetIpMulticastLoopbackResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x3b6b26ff558298f2 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpMulticastLoopback {
                        responder: SynchronousDatagramSocketGetIpMulticastLoopbackResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x76bc7df115a3b4d0 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::AddIpMembership {membership: req.membership,

                        responder: SynchronousDatagramSocketAddIpMembershipResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2888f3099188d03 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::DropIpMembership {membership: req.membership,

                        responder: SynchronousDatagramSocketDropIpMembershipResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1ae532b0c066e3a0 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTransparentRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpTransparent {value: req.value,

                        responder: SynchronousDatagramSocketSetIpTransparentResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x51d43695962ebfb5 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpTransparent {
                        responder: SynchronousDatagramSocketGetIpTransparentResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4722b4ce52f7840 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpReceiveOriginalDestinationAddress {value: req.value,

                        responder: SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2a0e7dc5d6bfdfe9 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpReceiveOriginalDestinationAddress {
                        responder: SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x7c94727acb4ea4b3 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::AddIpv6Membership {membership: req.membership,

                        responder: SynchronousDatagramSocketAddIpv6MembershipResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x42104c70ccaba304 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketDropIpv6MembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::DropIpv6Membership {membership: req.membership,

                        responder: SynchronousDatagramSocketDropIpv6MembershipResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x135f76db3774ab3b => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6MulticastInterfaceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpv6MulticastInterface {value: req.value,

                        responder: SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x1f26fcdd348f1882 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpv6MulticastInterface {
                        responder: SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x157d51e98f462859 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6UnicastHopsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6UnicastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpv6UnicastHops {value: req.value,

                        responder: SynchronousDatagramSocketSetIpv6UnicastHopsResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x21f4641cad8bd8d2 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpv6UnicastHops {
                        responder: SynchronousDatagramSocketGetIpv6UnicastHopsResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x5c24808ed2e84a1e => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6ReceiveHopLimitRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveHopLimitRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpv6ReceiveHopLimit {value: req.value,

                        responder: SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x341e06689885b4c0 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpv6ReceiveHopLimit {
                        responder: SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x25b9cd4d181f82c1 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6MulticastHopsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpv6MulticastHops {value: req.value,

                        responder: SynchronousDatagramSocketSetIpv6MulticastHopsResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x52916948a365012a => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpv6MulticastHops {
                        responder: SynchronousDatagramSocketGetIpv6MulticastHopsResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x55701c409ff41b40 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6MulticastLoopbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpv6MulticastLoopback {value: req.value,

                        responder: SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4415b701fde319c3 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpv6MulticastLoopback {
                        responder: SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4873f1364758cbba => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6OnlyRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpv6Only {value: req.value,

                        responder: SynchronousDatagramSocketSetIpv6OnlyResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x4aa3340a1a26b89c => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpv6Only {
                        responder: SynchronousDatagramSocketGetIpv6OnlyResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x58f07c8788d099a0 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpv6ReceiveTrafficClass {value: req.value,

                        responder: SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2e334df1da553ffa => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpv6ReceiveTrafficClass {
                        responder: SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6af077800c5a0b4f => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6TrafficClassRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6TrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpv6TrafficClass {value: req.value,

                        responder: SynchronousDatagramSocketSetIpv6TrafficClassResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x6baf6eed8fc2f04 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpv6TrafficClass {
                        responder: SynchronousDatagramSocketGetIpv6TrafficClassResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x19259775b1a92768 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6ReceivePacketInfoRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceivePacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SetIpv6ReceivePacketInfo {value: req.value,

                        responder: SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x7acd4a2775baec75 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetIpv6ReceivePacketInfo {
                        responder: SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x38bf28f0dafdbac0 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetOriginalDestination {
                        responder: SynchronousDatagramSocketGetOriginalDestinationResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x48aa0a1f6a32d2ed => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::GetInfo {
                        responder: SynchronousDatagramSocketGetInfoResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x585f20b73631070d => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::Describe {
                        responder: SynchronousDatagramSocketDescribeResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x28e494e48fb5dbf3 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(SynchronousDatagramSocketRecvMsgRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SynchronousDatagramSocketRecvMsgRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::RecvMsg {want_addr: req.want_addr,
data_len: req.data_len,
want_control: req.want_control,
flags: req.flags,

                        responder: SynchronousDatagramSocketRecvMsgResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x12dc2fceab6cefaa => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(SynchronousDatagramSocketSendMsgRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SynchronousDatagramSocketSendMsgRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = SynchronousDatagramSocketControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(SynchronousDatagramSocketRequest::SendMsg {addr: req.addr,
data: req.data,
control: req.control,
flags: req.flags,

                        responder: SynchronousDatagramSocketSendMsgResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <SynchronousDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// A synchronous datagram socket.
///
/// This protocol defines synchronous methods for sending and receiving datagram
/// payloads over a channel. All methods are nonblocking; their behavior roughly
/// matches their Linux counterparts.
///
/// *Warning:* This protocol is not yet ready for direct use by clients.
/// Instead, clients should use the BSD sockets API to interact with sockets.
/// We plan to change this protocol substantially and clients that couple
/// directly to this protocol will make those changes more difficult.
#[derive(Debug)]
pub enum SynchronousDatagramSocketRequest {
    Clone {
        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
        control_handle: SynchronousDatagramSocketControlHandle,
    },
    /// Terminates the connection.
    ///
    /// After calling `Close`, the client must not send any other requests.
    ///
    /// Servers, after sending the status response, should close the connection
    /// regardless of status and without sending an epitaph.
    ///
    /// Closing the client end of the channel should be semantically equivalent
    /// to calling `Close` without knowing when the close has completed or its
    /// status.
    Close {
        responder: SynchronousDatagramSocketCloseResponder,
    },
    Query {
        responder: SynchronousDatagramSocketQueryResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
    SetReuseAddress {
        value: bool,
        responder: SynchronousDatagramSocketSetReuseAddressResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
    GetReuseAddress {
        responder: SynchronousDatagramSocketGetReuseAddressResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_ERROR`.
    /// Returns the last error if there is an error set on the socket.
    GetError {
        responder: SynchronousDatagramSocketGetErrorResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
    SetBroadcast {
        value: bool,
        responder: SynchronousDatagramSocketSetBroadcastResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
    GetBroadcast {
        responder: SynchronousDatagramSocketGetBroadcastResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
    SetSendBuffer {
        value_bytes: u64,
        responder: SynchronousDatagramSocketSetSendBufferResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
    GetSendBuffer {
        responder: SynchronousDatagramSocketGetSendBufferResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
    SetReceiveBuffer {
        value_bytes: u64,
        responder: SynchronousDatagramSocketSetReceiveBufferResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
    GetReceiveBuffer {
        responder: SynchronousDatagramSocketGetReceiveBufferResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
    SetKeepAlive {
        value: bool,
        responder: SynchronousDatagramSocketSetKeepAliveResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
    GetKeepAlive {
        responder: SynchronousDatagramSocketGetKeepAliveResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
    SetOutOfBandInline {
        value: bool,
        responder: SynchronousDatagramSocketSetOutOfBandInlineResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
    GetOutOfBandInline {
        responder: SynchronousDatagramSocketGetOutOfBandInlineResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
    SetNoCheck {
        value: bool,
        responder: SynchronousDatagramSocketSetNoCheckResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
    GetNoCheck {
        responder: SynchronousDatagramSocketGetNoCheckResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_LINGER`.
    SetLinger {
        linger: bool,
        length_secs: u32,
        responder: SynchronousDatagramSocketSetLingerResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_LINGER`.
    GetLinger {
        responder: SynchronousDatagramSocketGetLingerResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
    SetReusePort {
        value: bool,
        responder: SynchronousDatagramSocketSetReusePortResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
    GetReusePort {
        responder: SynchronousDatagramSocketGetReusePortResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
    GetAcceptConn {
        responder: SynchronousDatagramSocketGetAcceptConnResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    SetBindToDevice {
        value: String,
        responder: SynchronousDatagramSocketSetBindToDeviceResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
    GetBindToDevice {
        responder: SynchronousDatagramSocketGetBindToDeviceResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    /// If `value` is 0, this clears the bound interface.
    SetBindToInterfaceIndex {
        value: u64,
        responder: SynchronousDatagramSocketSetBindToInterfaceIndexResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
    GetBindToInterfaceIndex {
        responder: SynchronousDatagramSocketGetBindToInterfaceIndexResponder,
    },
    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    SetTimestamp {
        value: TimestampOption,
        responder: SynchronousDatagramSocketSetTimestampResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
    GetTimestamp {
        responder: SynchronousDatagramSocketGetTimestampResponder,
    },
    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be set independently in each domain.
    SetMark {
        domain: fidl_fuchsia_net::MarkDomain,
        mark: OptionalUint32,
        responder: SynchronousDatagramSocketSetMarkResponder,
    },
    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
    /// unlike the standard SO_MARK, this API has multiple mark domains and each
    /// mark can be retrieved independently in each domain.
    GetMark {
        domain: fidl_fuchsia_net::MarkDomain,
        responder: SynchronousDatagramSocketGetMarkResponder,
    },
    /// Get `SOL_SOCKET` -> `SO_COOKIE`.
    GetCookie {
        responder: SynchronousDatagramSocketGetCookieResponder,
    },
    /// Sets the local address used for the socket.
    Bind {
        addr: fidl_fuchsia_net::SocketAddress,
        responder: SynchronousDatagramSocketBindResponder,
    },
    /// Initiates a connection to a remote address.
    Connect {
        addr: fidl_fuchsia_net::SocketAddress,
        responder: SynchronousDatagramSocketConnectResponder,
    },
    /// Clears connection information from this socket.
    Disconnect {
        responder: SynchronousDatagramSocketDisconnectResponder,
    },
    /// Retrieves the local socket address.
    GetSockName {
        responder: SynchronousDatagramSocketGetSockNameResponder,
    },
    /// Retrieves the remote socket address.
    GetPeerName {
        responder: SynchronousDatagramSocketGetPeerNameResponder,
    },
    /// Shuts down part of the socket.
    Shutdown {
        mode: ShutdownMode,
        responder: SynchronousDatagramSocketShutdownResponder,
    },
    /// Set `SOL_IP` -> `IP_TOS`.
    SetIpTypeOfService {
        value: u8,
        responder: SynchronousDatagramSocketSetIpTypeOfServiceResponder,
    },
    /// Get `SOL_IP` -> `IP_TOS`.
    GetIpTypeOfService {
        responder: SynchronousDatagramSocketGetIpTypeOfServiceResponder,
    },
    /// Set `SOL_IP` -> `IP_TTL`.
    SetIpTtl {
        value: OptionalUint8,
        responder: SynchronousDatagramSocketSetIpTtlResponder,
    },
    /// Get `SOL_IP` -> `IP_TTL`.
    GetIpTtl {
        responder: SynchronousDatagramSocketGetIpTtlResponder,
    },
    /// Set `SOL_IP` -> `IP_PKTINFO`.
    SetIpPacketInfo {
        value: bool,
        responder: SynchronousDatagramSocketSetIpPacketInfoResponder,
    },
    /// Get `SOL_IP` -> `IP_PKTINFO`.
    GetIpPacketInfo {
        responder: SynchronousDatagramSocketGetIpPacketInfoResponder,
    },
    /// Set `SOL_IP` -> `IP_RECVTOS`.
    SetIpReceiveTypeOfService {
        value: bool,
        responder: SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder,
    },
    /// Get `SOL_IP` -> `IP_RECVTOS`.
    GetIpReceiveTypeOfService {
        responder: SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder,
    },
    /// Set `SOL_IP` -> `IP_RECVTTL`.
    SetIpReceiveTtl {
        value: bool,
        responder: SynchronousDatagramSocketSetIpReceiveTtlResponder,
    },
    /// Get `SOL_IP` -> `IP_RECVTTL`.
    GetIpReceiveTtl {
        responder: SynchronousDatagramSocketGetIpReceiveTtlResponder,
    },
    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
    SetIpMulticastInterface {
        iface: u64,
        address: fidl_fuchsia_net::Ipv4Address,
        responder: SynchronousDatagramSocketSetIpMulticastInterfaceResponder,
    },
    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
    GetIpMulticastInterface {
        responder: SynchronousDatagramSocketGetIpMulticastInterfaceResponder,
    },
    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
    SetIpMulticastTtl {
        value: OptionalUint8,
        responder: SynchronousDatagramSocketSetIpMulticastTtlResponder,
    },
    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
    GetIpMulticastTtl {
        responder: SynchronousDatagramSocketGetIpMulticastTtlResponder,
    },
    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
    SetIpMulticastLoopback {
        value: bool,
        responder: SynchronousDatagramSocketSetIpMulticastLoopbackResponder,
    },
    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
    GetIpMulticastLoopback {
        responder: SynchronousDatagramSocketGetIpMulticastLoopbackResponder,
    },
    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
    AddIpMembership {
        membership: IpMulticastMembership,
        responder: SynchronousDatagramSocketAddIpMembershipResponder,
    },
    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
    DropIpMembership {
        membership: IpMulticastMembership,
        responder: SynchronousDatagramSocketDropIpMembershipResponder,
    },
    /// Set `SOL_IP` -> `IP_TRANSPARENT`
    SetIpTransparent {
        value: bool,
        responder: SynchronousDatagramSocketSetIpTransparentResponder,
    },
    /// Get `SOL_IP` -> `IP_TRANSPARENT`
    GetIpTransparent {
        responder: SynchronousDatagramSocketGetIpTransparentResponder,
    },
    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
    SetIpReceiveOriginalDestinationAddress {
        value: bool,
        responder: SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder,
    },
    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
    GetIpReceiveOriginalDestinationAddress {
        responder: SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
    AddIpv6Membership {
        membership: Ipv6MulticastMembership,
        responder: SynchronousDatagramSocketAddIpv6MembershipResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
    DropIpv6Membership {
        membership: Ipv6MulticastMembership,
        responder: SynchronousDatagramSocketDropIpv6MembershipResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    SetIpv6MulticastInterface {
        value: u64,
        responder: SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
    GetIpv6MulticastInterface {
        responder: SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    SetIpv6UnicastHops {
        value: OptionalUint8,
        responder: SynchronousDatagramSocketSetIpv6UnicastHopsResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
    GetIpv6UnicastHops {
        responder: SynchronousDatagramSocketGetIpv6UnicastHopsResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    SetIpv6ReceiveHopLimit {
        value: bool,
        responder: SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
    GetIpv6ReceiveHopLimit {
        responder: SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    SetIpv6MulticastHops {
        value: OptionalUint8,
        responder: SynchronousDatagramSocketSetIpv6MulticastHopsResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
    GetIpv6MulticastHops {
        responder: SynchronousDatagramSocketGetIpv6MulticastHopsResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    SetIpv6MulticastLoopback {
        value: bool,
        responder: SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
    GetIpv6MulticastLoopback {
        responder: SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
    SetIpv6Only {
        value: bool,
        responder: SynchronousDatagramSocketSetIpv6OnlyResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
    GetIpv6Only {
        responder: SynchronousDatagramSocketGetIpv6OnlyResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    SetIpv6ReceiveTrafficClass {
        value: bool,
        responder: SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
    GetIpv6ReceiveTrafficClass {
        responder: SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
    SetIpv6TrafficClass {
        value: OptionalUint8,
        responder: SynchronousDatagramSocketSetIpv6TrafficClassResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
    GetIpv6TrafficClass {
        responder: SynchronousDatagramSocketGetIpv6TrafficClassResponder,
    },
    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    SetIpv6ReceivePacketInfo {
        value: bool,
        responder: SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder,
    },
    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
    GetIpv6ReceivePacketInfo {
        responder: SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder,
    },
    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
    GetOriginalDestination {
        responder: SynchronousDatagramSocketGetOriginalDestinationResponder,
    },
    /// Retrieves creation information from the socket.
    ///
    /// - response `domain` the socket's associated domain.
    /// - response `proto` the socket's associated protocol.
    GetInfo {
        responder: SynchronousDatagramSocketGetInfoResponder,
    },
    Describe {
        responder: SynchronousDatagramSocketDescribeResponder,
    },
    /// Receives a message from the socket.
    ///
    /// + request `want_addr` request message's source address information to
    ///   be returned.
    /// + request `data_len` the maximum allowed length of the response data
    ///   buffer.
    /// + request `want_control` request ancillary data to be returned.
    /// + request `flags` flags for the receive request.
    /// - response `addr` the message's source address information, if
    ///   requested.
    /// - response `data` the message.
    /// - response `control` control messages, if requested.
    /// - response `truncated` indicates whether or not the returned message
    ///   was truncated.
    RecvMsg {
        want_addr: bool,
        data_len: u32,
        want_control: bool,
        flags: RecvMsgFlags,
        responder: SynchronousDatagramSocketRecvMsgResponder,
    },
    /// Sends a message on the socket.
    ///
    /// + request `addr` the address to send the message to. If unset, will send
    ///   to the connected peer.
    /// + request `data` the message.
    /// + request `control` ancillary data.
    /// + request `flags` flags for the send request.
    /// - response `len` the number of bytes sent.
    SendMsg {
        addr: Option<Box<fidl_fuchsia_net::SocketAddress>>,
        data: Vec<u8>,
        control: DatagramSocketSendControlData,
        flags: SendMsgFlags,
        responder: SynchronousDatagramSocketSendMsgResponder,
    },
}

impl SynchronousDatagramSocketRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_clone(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
        SynchronousDatagramSocketControlHandle,
    )> {
        if let SynchronousDatagramSocketRequest::Clone { request, control_handle } = self {
            Some((request, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_close(self) -> Option<(SynchronousDatagramSocketCloseResponder)> {
        if let SynchronousDatagramSocketRequest::Close { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_query(self) -> Option<(SynchronousDatagramSocketQueryResponder)> {
        if let SynchronousDatagramSocketRequest::Query { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_reuse_address(
        self,
    ) -> Option<(bool, SynchronousDatagramSocketSetReuseAddressResponder)> {
        if let SynchronousDatagramSocketRequest::SetReuseAddress { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_reuse_address(
        self,
    ) -> Option<(SynchronousDatagramSocketGetReuseAddressResponder)> {
        if let SynchronousDatagramSocketRequest::GetReuseAddress { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_error(self) -> Option<(SynchronousDatagramSocketGetErrorResponder)> {
        if let SynchronousDatagramSocketRequest::GetError { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_broadcast(
        self,
    ) -> Option<(bool, SynchronousDatagramSocketSetBroadcastResponder)> {
        if let SynchronousDatagramSocketRequest::SetBroadcast { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_broadcast(self) -> Option<(SynchronousDatagramSocketGetBroadcastResponder)> {
        if let SynchronousDatagramSocketRequest::GetBroadcast { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_send_buffer(
        self,
    ) -> Option<(u64, SynchronousDatagramSocketSetSendBufferResponder)> {
        if let SynchronousDatagramSocketRequest::SetSendBuffer { value_bytes, responder } = self {
            Some((value_bytes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_send_buffer(self) -> Option<(SynchronousDatagramSocketGetSendBufferResponder)> {
        if let SynchronousDatagramSocketRequest::GetSendBuffer { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_receive_buffer(
        self,
    ) -> Option<(u64, SynchronousDatagramSocketSetReceiveBufferResponder)> {
        if let SynchronousDatagramSocketRequest::SetReceiveBuffer { value_bytes, responder } = self
        {
            Some((value_bytes, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_receive_buffer(
        self,
    ) -> Option<(SynchronousDatagramSocketGetReceiveBufferResponder)> {
        if let SynchronousDatagramSocketRequest::GetReceiveBuffer { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_keep_alive(
        self,
    ) -> Option<(bool, SynchronousDatagramSocketSetKeepAliveResponder)> {
        if let SynchronousDatagramSocketRequest::SetKeepAlive { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_keep_alive(self) -> Option<(SynchronousDatagramSocketGetKeepAliveResponder)> {
        if let SynchronousDatagramSocketRequest::GetKeepAlive { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_out_of_band_inline(
        self,
    ) -> Option<(bool, SynchronousDatagramSocketSetOutOfBandInlineResponder)> {
        if let SynchronousDatagramSocketRequest::SetOutOfBandInline { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_out_of_band_inline(
        self,
    ) -> Option<(SynchronousDatagramSocketGetOutOfBandInlineResponder)> {
        if let SynchronousDatagramSocketRequest::GetOutOfBandInline { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_no_check(self) -> Option<(bool, SynchronousDatagramSocketSetNoCheckResponder)> {
        if let SynchronousDatagramSocketRequest::SetNoCheck { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_no_check(self) -> Option<(SynchronousDatagramSocketGetNoCheckResponder)> {
        if let SynchronousDatagramSocketRequest::GetNoCheck { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_linger(
        self,
    ) -> Option<(bool, u32, SynchronousDatagramSocketSetLingerResponder)> {
        if let SynchronousDatagramSocketRequest::SetLinger { linger, length_secs, responder } = self
        {
            Some((linger, length_secs, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_linger(self) -> Option<(SynchronousDatagramSocketGetLingerResponder)> {
        if let SynchronousDatagramSocketRequest::GetLinger { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_reuse_port(
        self,
    ) -> Option<(bool, SynchronousDatagramSocketSetReusePortResponder)> {
        if let SynchronousDatagramSocketRequest::SetReusePort { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_reuse_port(self) -> Option<(SynchronousDatagramSocketGetReusePortResponder)> {
        if let SynchronousDatagramSocketRequest::GetReusePort { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_accept_conn(self) -> Option<(SynchronousDatagramSocketGetAcceptConnResponder)> {
        if let SynchronousDatagramSocketRequest::GetAcceptConn { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_bind_to_device(
        self,
    ) -> Option<(String, SynchronousDatagramSocketSetBindToDeviceResponder)> {
        if let SynchronousDatagramSocketRequest::SetBindToDevice { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_bind_to_device(
        self,
    ) -> Option<(SynchronousDatagramSocketGetBindToDeviceResponder)> {
        if let SynchronousDatagramSocketRequest::GetBindToDevice { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_bind_to_interface_index(
        self,
    ) -> Option<(u64, SynchronousDatagramSocketSetBindToInterfaceIndexResponder)> {
        if let SynchronousDatagramSocketRequest::SetBindToInterfaceIndex { value, responder } = self
        {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_bind_to_interface_index(
        self,
    ) -> Option<(SynchronousDatagramSocketGetBindToInterfaceIndexResponder)> {
        if let SynchronousDatagramSocketRequest::GetBindToInterfaceIndex { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_timestamp(
        self,
    ) -> Option<(TimestampOption, SynchronousDatagramSocketSetTimestampResponder)> {
        if let SynchronousDatagramSocketRequest::SetTimestamp { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_timestamp(self) -> Option<(SynchronousDatagramSocketGetTimestampResponder)> {
        if let SynchronousDatagramSocketRequest::GetTimestamp { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_mark(
        self,
    ) -> Option<(
        fidl_fuchsia_net::MarkDomain,
        OptionalUint32,
        SynchronousDatagramSocketSetMarkResponder,
    )> {
        if let SynchronousDatagramSocketRequest::SetMark { domain, mark, responder } = self {
            Some((domain, mark, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_mark(
        self,
    ) -> Option<(fidl_fuchsia_net::MarkDomain, SynchronousDatagramSocketGetMarkResponder)> {
        if let SynchronousDatagramSocketRequest::GetMark { domain, responder } = self {
            Some((domain, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_cookie(self) -> Option<(SynchronousDatagramSocketGetCookieResponder)> {
        if let SynchronousDatagramSocketRequest::GetCookie { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_bind(
        self,
    ) -> Option<(fidl_fuchsia_net::SocketAddress, SynchronousDatagramSocketBindResponder)> {
        if let SynchronousDatagramSocketRequest::Bind { addr, responder } = self {
            Some((addr, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_connect(
        self,
    ) -> Option<(fidl_fuchsia_net::SocketAddress, SynchronousDatagramSocketConnectResponder)> {
        if let SynchronousDatagramSocketRequest::Connect { addr, responder } = self {
            Some((addr, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_disconnect(self) -> Option<(SynchronousDatagramSocketDisconnectResponder)> {
        if let SynchronousDatagramSocketRequest::Disconnect { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_sock_name(self) -> Option<(SynchronousDatagramSocketGetSockNameResponder)> {
        if let SynchronousDatagramSocketRequest::GetSockName { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_peer_name(self) -> Option<(SynchronousDatagramSocketGetPeerNameResponder)> {
        if let SynchronousDatagramSocketRequest::GetPeerName { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_shutdown(
        self,
    ) -> Option<(ShutdownMode, SynchronousDatagramSocketShutdownResponder)> {
        if let SynchronousDatagramSocketRequest::Shutdown { mode, responder } = self {
            Some((mode, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_type_of_service(
        self,
    ) -> Option<(u8, SynchronousDatagramSocketSetIpTypeOfServiceResponder)> {
        if let SynchronousDatagramSocketRequest::SetIpTypeOfService { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_type_of_service(
        self,
    ) -> Option<(SynchronousDatagramSocketGetIpTypeOfServiceResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpTypeOfService { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_ttl(
        self,
    ) -> Option<(OptionalUint8, SynchronousDatagramSocketSetIpTtlResponder)> {
        if let SynchronousDatagramSocketRequest::SetIpTtl { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_ttl(self) -> Option<(SynchronousDatagramSocketGetIpTtlResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpTtl { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_packet_info(
        self,
    ) -> Option<(bool, SynchronousDatagramSocketSetIpPacketInfoResponder)> {
        if let SynchronousDatagramSocketRequest::SetIpPacketInfo { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_packet_info(
        self,
    ) -> Option<(SynchronousDatagramSocketGetIpPacketInfoResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpPacketInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_receive_type_of_service(
        self,
    ) -> Option<(bool, SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder)> {
        if let SynchronousDatagramSocketRequest::SetIpReceiveTypeOfService { value, responder } =
            self
        {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_receive_type_of_service(
        self,
    ) -> Option<(SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpReceiveTypeOfService { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_receive_ttl(
        self,
    ) -> Option<(bool, SynchronousDatagramSocketSetIpReceiveTtlResponder)> {
        if let SynchronousDatagramSocketRequest::SetIpReceiveTtl { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_receive_ttl(
        self,
    ) -> Option<(SynchronousDatagramSocketGetIpReceiveTtlResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpReceiveTtl { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_multicast_interface(
        self,
    ) -> Option<(
        u64,
        fidl_fuchsia_net::Ipv4Address,
        SynchronousDatagramSocketSetIpMulticastInterfaceResponder,
    )> {
        if let SynchronousDatagramSocketRequest::SetIpMulticastInterface {
            iface,
            address,
            responder,
        } = self
        {
            Some((iface, address, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_multicast_interface(
        self,
    ) -> Option<(SynchronousDatagramSocketGetIpMulticastInterfaceResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpMulticastInterface { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_multicast_ttl(
        self,
    ) -> Option<(OptionalUint8, SynchronousDatagramSocketSetIpMulticastTtlResponder)> {
        if let SynchronousDatagramSocketRequest::SetIpMulticastTtl { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_multicast_ttl(
        self,
    ) -> Option<(SynchronousDatagramSocketGetIpMulticastTtlResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpMulticastTtl { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_multicast_loopback(
        self,
    ) -> Option<(bool, SynchronousDatagramSocketSetIpMulticastLoopbackResponder)> {
        if let SynchronousDatagramSocketRequest::SetIpMulticastLoopback { value, responder } = self
        {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_multicast_loopback(
        self,
    ) -> Option<(SynchronousDatagramSocketGetIpMulticastLoopbackResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpMulticastLoopback { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_ip_membership(
        self,
    ) -> Option<(IpMulticastMembership, SynchronousDatagramSocketAddIpMembershipResponder)> {
        if let SynchronousDatagramSocketRequest::AddIpMembership { membership, responder } = self {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_drop_ip_membership(
        self,
    ) -> Option<(IpMulticastMembership, SynchronousDatagramSocketDropIpMembershipResponder)> {
        if let SynchronousDatagramSocketRequest::DropIpMembership { membership, responder } = self {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_transparent(
        self,
    ) -> Option<(bool, SynchronousDatagramSocketSetIpTransparentResponder)> {
        if let SynchronousDatagramSocketRequest::SetIpTransparent { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_transparent(
        self,
    ) -> Option<(SynchronousDatagramSocketGetIpTransparentResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpTransparent { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ip_receive_original_destination_address(
        self,
    ) -> Option<(bool, SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder)>
    {
        if let SynchronousDatagramSocketRequest::SetIpReceiveOriginalDestinationAddress {
            value,
            responder,
        } = self
        {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ip_receive_original_destination_address(
        self,
    ) -> Option<(SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpReceiveOriginalDestinationAddress {
            responder,
        } = self
        {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_ipv6_membership(
        self,
    ) -> Option<(Ipv6MulticastMembership, SynchronousDatagramSocketAddIpv6MembershipResponder)>
    {
        if let SynchronousDatagramSocketRequest::AddIpv6Membership { membership, responder } = self
        {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_drop_ipv6_membership(
        self,
    ) -> Option<(Ipv6MulticastMembership, SynchronousDatagramSocketDropIpv6MembershipResponder)>
    {
        if let SynchronousDatagramSocketRequest::DropIpv6Membership { membership, responder } = self
        {
            Some((membership, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_multicast_interface(
        self,
    ) -> Option<(u64, SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder)> {
        if let SynchronousDatagramSocketRequest::SetIpv6MulticastInterface { value, responder } =
            self
        {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_multicast_interface(
        self,
    ) -> Option<(SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpv6MulticastInterface { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_unicast_hops(
        self,
    ) -> Option<(OptionalUint8, SynchronousDatagramSocketSetIpv6UnicastHopsResponder)> {
        if let SynchronousDatagramSocketRequest::SetIpv6UnicastHops { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_unicast_hops(
        self,
    ) -> Option<(SynchronousDatagramSocketGetIpv6UnicastHopsResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpv6UnicastHops { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_receive_hop_limit(
        self,
    ) -> Option<(bool, SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder)> {
        if let SynchronousDatagramSocketRequest::SetIpv6ReceiveHopLimit { value, responder } = self
        {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_receive_hop_limit(
        self,
    ) -> Option<(SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpv6ReceiveHopLimit { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_multicast_hops(
        self,
    ) -> Option<(OptionalUint8, SynchronousDatagramSocketSetIpv6MulticastHopsResponder)> {
        if let SynchronousDatagramSocketRequest::SetIpv6MulticastHops { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_multicast_hops(
        self,
    ) -> Option<(SynchronousDatagramSocketGetIpv6MulticastHopsResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpv6MulticastHops { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_multicast_loopback(
        self,
    ) -> Option<(bool, SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder)> {
        if let SynchronousDatagramSocketRequest::SetIpv6MulticastLoopback { value, responder } =
            self
        {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_multicast_loopback(
        self,
    ) -> Option<(SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpv6MulticastLoopback { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_only(
        self,
    ) -> Option<(bool, SynchronousDatagramSocketSetIpv6OnlyResponder)> {
        if let SynchronousDatagramSocketRequest::SetIpv6Only { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_only(self) -> Option<(SynchronousDatagramSocketGetIpv6OnlyResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpv6Only { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_receive_traffic_class(
        self,
    ) -> Option<(bool, SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder)> {
        if let SynchronousDatagramSocketRequest::SetIpv6ReceiveTrafficClass { value, responder } =
            self
        {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_receive_traffic_class(
        self,
    ) -> Option<(SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpv6ReceiveTrafficClass { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_traffic_class(
        self,
    ) -> Option<(OptionalUint8, SynchronousDatagramSocketSetIpv6TrafficClassResponder)> {
        if let SynchronousDatagramSocketRequest::SetIpv6TrafficClass { value, responder } = self {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_traffic_class(
        self,
    ) -> Option<(SynchronousDatagramSocketGetIpv6TrafficClassResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpv6TrafficClass { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_ipv6_receive_packet_info(
        self,
    ) -> Option<(bool, SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder)> {
        if let SynchronousDatagramSocketRequest::SetIpv6ReceivePacketInfo { value, responder } =
            self
        {
            Some((value, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_ipv6_receive_packet_info(
        self,
    ) -> Option<(SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder)> {
        if let SynchronousDatagramSocketRequest::GetIpv6ReceivePacketInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_original_destination(
        self,
    ) -> Option<(SynchronousDatagramSocketGetOriginalDestinationResponder)> {
        if let SynchronousDatagramSocketRequest::GetOriginalDestination { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_info(self) -> Option<(SynchronousDatagramSocketGetInfoResponder)> {
        if let SynchronousDatagramSocketRequest::GetInfo { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_describe(self) -> Option<(SynchronousDatagramSocketDescribeResponder)> {
        if let SynchronousDatagramSocketRequest::Describe { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_recv_msg(
        self,
    ) -> Option<(bool, u32, bool, RecvMsgFlags, SynchronousDatagramSocketRecvMsgResponder)> {
        if let SynchronousDatagramSocketRequest::RecvMsg {
            want_addr,
            data_len,
            want_control,
            flags,
            responder,
        } = self
        {
            Some((want_addr, data_len, want_control, flags, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_send_msg(
        self,
    ) -> Option<(
        Option<Box<fidl_fuchsia_net::SocketAddress>>,
        Vec<u8>,
        DatagramSocketSendControlData,
        SendMsgFlags,
        SynchronousDatagramSocketSendMsgResponder,
    )> {
        if let SynchronousDatagramSocketRequest::SendMsg { addr, data, control, flags, responder } =
            self
        {
            Some((addr, data, control, flags, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            SynchronousDatagramSocketRequest::Clone { .. } => "clone",
            SynchronousDatagramSocketRequest::Close { .. } => "close",
            SynchronousDatagramSocketRequest::Query { .. } => "query",
            SynchronousDatagramSocketRequest::SetReuseAddress { .. } => "set_reuse_address",
            SynchronousDatagramSocketRequest::GetReuseAddress { .. } => "get_reuse_address",
            SynchronousDatagramSocketRequest::GetError { .. } => "get_error",
            SynchronousDatagramSocketRequest::SetBroadcast { .. } => "set_broadcast",
            SynchronousDatagramSocketRequest::GetBroadcast { .. } => "get_broadcast",
            SynchronousDatagramSocketRequest::SetSendBuffer { .. } => "set_send_buffer",
            SynchronousDatagramSocketRequest::GetSendBuffer { .. } => "get_send_buffer",
            SynchronousDatagramSocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
            SynchronousDatagramSocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
            SynchronousDatagramSocketRequest::SetKeepAlive { .. } => "set_keep_alive",
            SynchronousDatagramSocketRequest::GetKeepAlive { .. } => "get_keep_alive",
            SynchronousDatagramSocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
            SynchronousDatagramSocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
            SynchronousDatagramSocketRequest::SetNoCheck { .. } => "set_no_check",
            SynchronousDatagramSocketRequest::GetNoCheck { .. } => "get_no_check",
            SynchronousDatagramSocketRequest::SetLinger { .. } => "set_linger",
            SynchronousDatagramSocketRequest::GetLinger { .. } => "get_linger",
            SynchronousDatagramSocketRequest::SetReusePort { .. } => "set_reuse_port",
            SynchronousDatagramSocketRequest::GetReusePort { .. } => "get_reuse_port",
            SynchronousDatagramSocketRequest::GetAcceptConn { .. } => "get_accept_conn",
            SynchronousDatagramSocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
            SynchronousDatagramSocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
            SynchronousDatagramSocketRequest::SetBindToInterfaceIndex { .. } => {
                "set_bind_to_interface_index"
            }
            SynchronousDatagramSocketRequest::GetBindToInterfaceIndex { .. } => {
                "get_bind_to_interface_index"
            }
            SynchronousDatagramSocketRequest::SetTimestamp { .. } => "set_timestamp",
            SynchronousDatagramSocketRequest::GetTimestamp { .. } => "get_timestamp",
            SynchronousDatagramSocketRequest::SetMark { .. } => "set_mark",
            SynchronousDatagramSocketRequest::GetMark { .. } => "get_mark",
            SynchronousDatagramSocketRequest::GetCookie { .. } => "get_cookie",
            SynchronousDatagramSocketRequest::Bind { .. } => "bind",
            SynchronousDatagramSocketRequest::Connect { .. } => "connect",
            SynchronousDatagramSocketRequest::Disconnect { .. } => "disconnect",
            SynchronousDatagramSocketRequest::GetSockName { .. } => "get_sock_name",
            SynchronousDatagramSocketRequest::GetPeerName { .. } => "get_peer_name",
            SynchronousDatagramSocketRequest::Shutdown { .. } => "shutdown",
            SynchronousDatagramSocketRequest::SetIpTypeOfService { .. } => "set_ip_type_of_service",
            SynchronousDatagramSocketRequest::GetIpTypeOfService { .. } => "get_ip_type_of_service",
            SynchronousDatagramSocketRequest::SetIpTtl { .. } => "set_ip_ttl",
            SynchronousDatagramSocketRequest::GetIpTtl { .. } => "get_ip_ttl",
            SynchronousDatagramSocketRequest::SetIpPacketInfo { .. } => "set_ip_packet_info",
            SynchronousDatagramSocketRequest::GetIpPacketInfo { .. } => "get_ip_packet_info",
            SynchronousDatagramSocketRequest::SetIpReceiveTypeOfService { .. } => {
                "set_ip_receive_type_of_service"
            }
            SynchronousDatagramSocketRequest::GetIpReceiveTypeOfService { .. } => {
                "get_ip_receive_type_of_service"
            }
            SynchronousDatagramSocketRequest::SetIpReceiveTtl { .. } => "set_ip_receive_ttl",
            SynchronousDatagramSocketRequest::GetIpReceiveTtl { .. } => "get_ip_receive_ttl",
            SynchronousDatagramSocketRequest::SetIpMulticastInterface { .. } => {
                "set_ip_multicast_interface"
            }
            SynchronousDatagramSocketRequest::GetIpMulticastInterface { .. } => {
                "get_ip_multicast_interface"
            }
            SynchronousDatagramSocketRequest::SetIpMulticastTtl { .. } => "set_ip_multicast_ttl",
            SynchronousDatagramSocketRequest::GetIpMulticastTtl { .. } => "get_ip_multicast_ttl",
            SynchronousDatagramSocketRequest::SetIpMulticastLoopback { .. } => {
                "set_ip_multicast_loopback"
            }
            SynchronousDatagramSocketRequest::GetIpMulticastLoopback { .. } => {
                "get_ip_multicast_loopback"
            }
            SynchronousDatagramSocketRequest::AddIpMembership { .. } => "add_ip_membership",
            SynchronousDatagramSocketRequest::DropIpMembership { .. } => "drop_ip_membership",
            SynchronousDatagramSocketRequest::SetIpTransparent { .. } => "set_ip_transparent",
            SynchronousDatagramSocketRequest::GetIpTransparent { .. } => "get_ip_transparent",
            SynchronousDatagramSocketRequest::SetIpReceiveOriginalDestinationAddress { .. } => {
                "set_ip_receive_original_destination_address"
            }
            SynchronousDatagramSocketRequest::GetIpReceiveOriginalDestinationAddress { .. } => {
                "get_ip_receive_original_destination_address"
            }
            SynchronousDatagramSocketRequest::AddIpv6Membership { .. } => "add_ipv6_membership",
            SynchronousDatagramSocketRequest::DropIpv6Membership { .. } => "drop_ipv6_membership",
            SynchronousDatagramSocketRequest::SetIpv6MulticastInterface { .. } => {
                "set_ipv6_multicast_interface"
            }
            SynchronousDatagramSocketRequest::GetIpv6MulticastInterface { .. } => {
                "get_ipv6_multicast_interface"
            }
            SynchronousDatagramSocketRequest::SetIpv6UnicastHops { .. } => "set_ipv6_unicast_hops",
            SynchronousDatagramSocketRequest::GetIpv6UnicastHops { .. } => "get_ipv6_unicast_hops",
            SynchronousDatagramSocketRequest::SetIpv6ReceiveHopLimit { .. } => {
                "set_ipv6_receive_hop_limit"
            }
            SynchronousDatagramSocketRequest::GetIpv6ReceiveHopLimit { .. } => {
                "get_ipv6_receive_hop_limit"
            }
            SynchronousDatagramSocketRequest::SetIpv6MulticastHops { .. } => {
                "set_ipv6_multicast_hops"
            }
            SynchronousDatagramSocketRequest::GetIpv6MulticastHops { .. } => {
                "get_ipv6_multicast_hops"
            }
            SynchronousDatagramSocketRequest::SetIpv6MulticastLoopback { .. } => {
                "set_ipv6_multicast_loopback"
            }
            SynchronousDatagramSocketRequest::GetIpv6MulticastLoopback { .. } => {
                "get_ipv6_multicast_loopback"
            }
            SynchronousDatagramSocketRequest::SetIpv6Only { .. } => "set_ipv6_only",
            SynchronousDatagramSocketRequest::GetIpv6Only { .. } => "get_ipv6_only",
            SynchronousDatagramSocketRequest::SetIpv6ReceiveTrafficClass { .. } => {
                "set_ipv6_receive_traffic_class"
            }
            SynchronousDatagramSocketRequest::GetIpv6ReceiveTrafficClass { .. } => {
                "get_ipv6_receive_traffic_class"
            }
            SynchronousDatagramSocketRequest::SetIpv6TrafficClass { .. } => {
                "set_ipv6_traffic_class"
            }
            SynchronousDatagramSocketRequest::GetIpv6TrafficClass { .. } => {
                "get_ipv6_traffic_class"
            }
            SynchronousDatagramSocketRequest::SetIpv6ReceivePacketInfo { .. } => {
                "set_ipv6_receive_packet_info"
            }
            SynchronousDatagramSocketRequest::GetIpv6ReceivePacketInfo { .. } => {
                "get_ipv6_receive_packet_info"
            }
            SynchronousDatagramSocketRequest::GetOriginalDestination { .. } => {
                "get_original_destination"
            }
            SynchronousDatagramSocketRequest::GetInfo { .. } => "get_info",
            SynchronousDatagramSocketRequest::Describe { .. } => "describe",
            SynchronousDatagramSocketRequest::RecvMsg { .. } => "recv_msg",
            SynchronousDatagramSocketRequest::SendMsg { .. } => "send_msg",
        }
    }
}

#[derive(Debug, Clone)]
pub struct SynchronousDatagramSocketControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for SynchronousDatagramSocketControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl SynchronousDatagramSocketControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketCloseResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketCloseResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketCloseResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketCloseResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
                result,
                self.tx_id,
                0x5ac5d459ad7f657e,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketQueryResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketQueryResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketQueryResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketQueryResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(protocol);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        let _result = self.send_raw(protocol);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
            (protocol,),
            self.tx_id,
            0x2658edee9decfc06,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetReuseAddressResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetReuseAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetReuseAddressResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetReuseAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x1fd74ee8b9a4a876,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetReuseAddressResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetReuseAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetReuseAddressResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetReuseAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetReuseAddressResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x67b7206b8d1bc0a5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetErrorResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetErrorResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetErrorResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetErrorResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x5aad39b33e5f6ebb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetBroadcastResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetBroadcastResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetBroadcastResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetBroadcastResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6023e081ce3cd947,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetBroadcastResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetBroadcastResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetBroadcastResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetBroadcastResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetBroadcastResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x68796fc556f9780d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetSendBufferResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetSendBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetSendBufferResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetSendBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x756eac32d73a7a70,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetSendBufferResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetSendBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetSendBufferResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetSendBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetSendBufferResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value_bytes| (value_bytes,)),
            self.tx_id,
            0x78a52fd9c7b2410b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetReceiveBufferResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetReceiveBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetReceiveBufferResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetReceiveBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6b0cf2f1919c7001,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetReceiveBufferResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetReceiveBufferResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetReceiveBufferResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetReceiveBufferResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetReceiveBufferResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value_bytes| (value_bytes,)),
            self.tx_id,
            0x14c1a4b64f709e5c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetKeepAliveResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetKeepAliveResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetKeepAliveResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetKeepAliveResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x572df8f0b920d2c7,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetKeepAliveResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetKeepAliveResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetKeepAliveResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetKeepAliveResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetKeepAliveResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2dd29d3215f2c9d2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetOutOfBandInlineResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetOutOfBandInlineResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetOutOfBandInlineResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetOutOfBandInlineResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x3ecb49968bee439,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetOutOfBandInlineResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetOutOfBandInlineResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetOutOfBandInlineResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetOutOfBandInlineResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetOutOfBandInlineResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x348c1ab3aeca1745,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetNoCheckResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetNoCheckResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetNoCheckResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetNoCheckResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6bbf00c53a4c78c2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetNoCheckResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetNoCheckResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetNoCheckResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetNoCheckResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetNoCheckResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2cd4249286417694,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetLingerResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetLingerResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetLingerResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetLingerResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x45386351246e998e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetLingerResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetLingerResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetLingerResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetLingerResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetLingerResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x48eb20fc5ccb0e45,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetReusePortResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetReusePortResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetReusePortResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetReusePortResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x24dd3e5cb36d9ccb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetReusePortResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetReusePortResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetReusePortResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetReusePortResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetReusePortResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x7a112c1ab54ff828,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetAcceptConnResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetAcceptConnResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetAcceptConnResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetAcceptConnResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetAcceptConnResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x67ce6db6c2ec8966,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetBindToDeviceResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetBindToDeviceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetBindToDeviceResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetBindToDeviceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x2118b483f28aafc4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetBindToDeviceResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetBindToDeviceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetBindToDeviceResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetBindToDeviceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetBindToDeviceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x1ab1fbf0ef7906c8,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetBindToInterfaceIndexResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetBindToInterfaceIndexResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetBindToInterfaceIndexResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetBindToInterfaceIndexResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6e387a0def00821,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetBindToInterfaceIndexResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetBindToInterfaceIndexResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetBindToInterfaceIndexResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetBindToInterfaceIndexResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetBindToInterfaceIndexResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x59c31dd3e3078295,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetTimestampResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetTimestampResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetTimestampResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetTimestampResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x285d6516c263d839,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetTimestampResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetTimestampResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetTimestampResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetTimestampResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetTimestampResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x49f2fffbbcc2bd27,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetMarkResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetMarkResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetMarkResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetMarkResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6ead6de09f653236,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetMarkResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetMarkResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetMarkResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetMarkResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetMarkResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|mark| (mark,)),
            self.tx_id,
            0x57a2752c61d93d47,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetCookieResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetCookieResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetCookieResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetCookieResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseSocketGetCookieResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2c2f47fd8f924e52,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketBindResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketBindResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketBindResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketBindResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x4bc6400ae92125d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketConnectResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketConnectResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketConnectResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketConnectResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x5f05f19bfdd38871,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketDisconnectResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketDisconnectResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketDisconnectResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketDisconnectResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x74e63b91f7b29b2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetSockNameResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetSockNameResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetSockNameResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetSockNameResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetSockNameResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|addr| (addr,)),
            self.tx_id,
            0x475f23f84a1a4f85,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetPeerNameResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetPeerNameResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetPeerNameResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetPeerNameResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetPeerNameResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|addr| (addr,)),
            self.tx_id,
            0x1ffecf4bd5b6432e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketShutdownResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketShutdownResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketShutdownResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketShutdownResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x247f38b6db68c336,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpTypeOfServiceResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x995c600475b6d46,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpTypeOfServiceResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpTypeOfServiceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x3814a04259f75fcb,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpTtlResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpTtlResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x29e2424b433ae1ef,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpTtlResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpTtlResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpTtlResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x47e47fa1f24da471,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpPacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpPacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpPacketInfoResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpPacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x392d16bee20c0e16,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpPacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpPacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpPacketInfoResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpPacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpPacketInfoResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x54b505f242280740,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6c4f6714995f84ef,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4158ba7dc2795960,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpReceiveTtlResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpReceiveTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpReceiveTtlResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpReceiveTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x46f15be0ce0ab82b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpReceiveTtlResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpReceiveTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpReceiveTtlResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpReceiveTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpReceiveTtlResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x678ddd5a5dfa2eb5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpMulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpMulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpMulticastInterfaceResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpMulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x752fbfa9b12befe,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpMulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpMulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpMulticastInterfaceResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpMulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpMulticastInterfaceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x320bd14c4df046c4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpMulticastTtlResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpMulticastTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpMulticastTtlResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpMulticastTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x63134d53772916a1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpMulticastTtlResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpMulticastTtlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpMulticastTtlResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpMulticastTtlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpMulticastTtlResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4665cd378f39e1a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpMulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpMulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpMulticastLoopbackResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpMulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x20c55c11f00943ea,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpMulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpMulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpMulticastLoopbackResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpMulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpMulticastLoopbackResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x3b6b26ff558298f2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketAddIpMembershipResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketAddIpMembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketAddIpMembershipResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketAddIpMembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x76bc7df115a3b4d0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketDropIpMembershipResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketDropIpMembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketDropIpMembershipResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketDropIpMembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x2888f3099188d03,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpTransparentResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpTransparentResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpTransparentResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpTransparentResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x1ae532b0c066e3a0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpTransparentResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpTransparentResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpTransparentResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpTransparentResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpTransparentResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x51d43695962ebfb5,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder
    for SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder
{
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x4722b4ce52f7840,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder
    for SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder
{
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2a0e7dc5d6bfdfe9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketAddIpv6MembershipResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketAddIpv6MembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketAddIpv6MembershipResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketAddIpv6MembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x7c94727acb4ea4b3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketDropIpv6MembershipResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketDropIpv6MembershipResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketDropIpv6MembershipResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketDropIpv6MembershipResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x42104c70ccaba304,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x135f76db3774ab3b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x1f26fcdd348f1882,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpv6UnicastHopsResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpv6UnicastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6UnicastHopsResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpv6UnicastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x157d51e98f462859,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpv6UnicastHopsResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpv6UnicastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6UnicastHopsResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpv6UnicastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6UnicastHopsResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x21f4641cad8bd8d2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x5c24808ed2e84a1e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x341e06689885b4c0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpv6MulticastHopsResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpv6MulticastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6MulticastHopsResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpv6MulticastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x25b9cd4d181f82c1,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpv6MulticastHopsResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpv6MulticastHopsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6MulticastHopsResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpv6MulticastHopsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6MulticastHopsResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x52916948a365012a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x55701c409ff41b40,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4415b701fde319c3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpv6OnlyResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpv6OnlyResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6OnlyResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpv6OnlyResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x4873f1364758cbba,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpv6OnlyResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpv6OnlyResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6OnlyResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpv6OnlyResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6OnlyResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x4aa3340a1a26b89c,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x58f07c8788d099a0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x2e334df1da553ffa,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpv6TrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpv6TrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6TrafficClassResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpv6TrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x6af077800c5a0b4f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpv6TrafficClassResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpv6TrafficClassResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6TrafficClassResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpv6TrafficClassResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6TrafficClassResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x6baf6eed8fc2f04,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x19259775b1a92768,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x7acd4a2775baec75,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetOriginalDestinationResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetOriginalDestinationResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetOriginalDestinationResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetOriginalDestinationResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseNetworkSocketGetOriginalDestinationResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|value| (value,)),
            self.tx_id,
            0x38bf28f0dafdbac0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketGetInfoResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketGetInfoResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketGetInfoResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketGetInfoResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            BaseDatagramSocketGetInfoResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x48aa0a1f6a32d2ed,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketDescribeResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketDescribeResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketDescribeResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketDescribeResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut payload: SynchronousDatagramSocketDescribeResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut payload: SynchronousDatagramSocketDescribeResponse,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(payload);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut payload: SynchronousDatagramSocketDescribeResponse,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<SynchronousDatagramSocketDescribeResponse>(
            &mut payload,
            self.tx_id,
            0x585f20b73631070d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketRecvMsgResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketRecvMsgResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketRecvMsgResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketRecvMsgResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<
            (Option<&fidl_fuchsia_net::SocketAddress>, &[u8], &DatagramSocketRecvControlData, u32),
            fidl_fuchsia_posix::Errno,
        >,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<
            (Option<&fidl_fuchsia_net::SocketAddress>, &[u8], &DatagramSocketRecvControlData, u32),
            fidl_fuchsia_posix::Errno,
        >,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<
            (Option<&fidl_fuchsia_net::SocketAddress>, &[u8], &DatagramSocketRecvControlData, u32),
            fidl_fuchsia_posix::Errno,
        >,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            SynchronousDatagramSocketRecvMsgResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result,
            self.tx_id,
            0x28e494e48fb5dbf3,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct SynchronousDatagramSocketSendMsgResponder {
    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for SynchronousDatagramSocketSendMsgResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for SynchronousDatagramSocketSendMsgResponder {
    type ControlHandle = SynchronousDatagramSocketControlHandle;

    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl SynchronousDatagramSocketSendMsgResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<i64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<i64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<i64, fidl_fuchsia_posix::Errno>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            SynchronousDatagramSocketSendMsgResponse,
            fidl_fuchsia_posix::Errno,
        >>(
            result.map(|len| (len,)),
            self.tx_id,
            0x12dc2fceab6cefaa,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;

    impl fidl::encoding::ResourceTypeMarker for ProviderDatagramSocketWithOptionsRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            ProviderDatagramSocketWithOptionsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ProviderDatagramSocketWithOptionsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProviderDatagramSocketWithOptionsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ProviderDatagramSocketWithOptionsRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <Domain as fidl::encoding::ValueTypeMarker>::borrow(&self.domain),
                    <DatagramSocketProtocol as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.proto,
                    ),
                    <SocketCreationOptions as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.opts,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<Domain, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<
                DatagramSocketProtocol,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T2: fidl::encoding::Encode<
                SocketCreationOptions,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ProviderDatagramSocketWithOptionsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProviderDatagramSocketWithOptionsRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ProviderDatagramSocketWithOptionsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                domain: fidl::new_empty!(Domain, fidl::encoding::DefaultFuchsiaResourceDialect),
                proto: fidl::new_empty!(
                    DatagramSocketProtocol,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                opts: fidl::new_empty!(
                    SocketCreationOptions,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffff0000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                Domain,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.domain,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                DatagramSocketProtocol,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.proto,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(
                SocketCreationOptions,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.opts,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ProviderStreamSocketWithOptionsRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            ProviderStreamSocketWithOptionsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ProviderStreamSocketWithOptionsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProviderStreamSocketWithOptionsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ProviderStreamSocketWithOptionsRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <Domain as fidl::encoding::ValueTypeMarker>::borrow(&self.domain),
                    <StreamSocketProtocol as fidl::encoding::ValueTypeMarker>::borrow(&self.proto),
                    <SocketCreationOptions as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.opts,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<Domain, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T1: fidl::encoding::Encode<StreamSocketProtocol, fidl::encoding::DefaultFuchsiaResourceDialect>,
        T2: fidl::encoding::Encode<
                SocketCreationOptions,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ProviderStreamSocketWithOptionsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProviderStreamSocketWithOptionsRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ProviderStreamSocketWithOptionsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                domain: fidl::new_empty!(Domain, fidl::encoding::DefaultFuchsiaResourceDialect),
                proto: fidl::new_empty!(
                    StreamSocketProtocol,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                opts: fidl::new_empty!(
                    SocketCreationOptions,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffff0000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                Domain,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.domain,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                StreamSocketProtocol,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.proto,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(
                SocketCreationOptions,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.opts,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ProviderDatagramSocketDeprecatedResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ProviderDatagramSocketDeprecatedResponse {
        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
        fidl::encoding::Encode<
            ProviderDatagramSocketDeprecatedResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ProviderDatagramSocketDeprecatedResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProviderDatagramSocketDeprecatedResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                ProviderDatagramSocketDeprecatedResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.s
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ProviderDatagramSocketDeprecatedResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProviderDatagramSocketDeprecatedResponse>(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 fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ProviderDatagramSocketDeprecatedResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                s: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for ProviderStreamSocketWithOptionsResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ProviderStreamSocketWithOptionsResponse {
        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
        fidl::encoding::Encode<
            ProviderStreamSocketWithOptionsResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ProviderStreamSocketWithOptionsResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProviderStreamSocketWithOptionsResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ProviderStreamSocketWithOptionsResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.s),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ProviderStreamSocketWithOptionsResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProviderStreamSocketWithOptionsResponse>(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 fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ProviderStreamSocketWithOptionsResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                s: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for ProviderStreamSocketResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ProviderStreamSocketResponse {
        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
        fidl::encoding::Encode<
            ProviderStreamSocketResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ProviderStreamSocketResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProviderStreamSocketResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ProviderStreamSocketResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.s),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            ProviderStreamSocketResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProviderStreamSocketResponse>(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 fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ProviderStreamSocketResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                s: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

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

    impl fidl::encoding::ResourceTypeMarker for StreamSocketAcceptResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

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

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

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

    unsafe impl
        fidl::encoding::Encode<
            StreamSocketAcceptResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut StreamSocketAcceptResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StreamSocketAcceptResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<StreamSocketAcceptResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress> as fidl::encoding::ValueTypeMarker>::borrow(&self.addr),
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.s),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
        T0: fidl::encoding::Encode<
                fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
    >
        fidl::encoding::Encode<
            StreamSocketAcceptResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StreamSocketAcceptResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for StreamSocketAcceptResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                addr: fidl::new_empty!(
                    fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                s: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.addr,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.s,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl DatagramSocketDescribeResponse {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.metadata_encoding_protocol_version {
                return 4;
            }
            if let Some(_) = self.rx_meta_buf_size {
                return 3;
            }
            if let Some(_) = self.tx_meta_buf_size {
                return 2;
            }
            if let Some(_) = self.socket {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DatagramSocketDescribeResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DatagramSocketDescribeResponse {
        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
        fidl::encoding::Encode<
            DatagramSocketDescribeResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DatagramSocketDescribeResponse
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DatagramSocketDescribeResponse>(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::encoding::HandleType<
                    fidl::Socket,
                    { fidl::ObjectType::SOCKET.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.socket.as_mut().map(
                    <fidl::encoding::HandleType<
                        fidl::Socket,
                        { fidl::ObjectType::SOCKET.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_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::<
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.tx_meta_buf_size
                    .as_ref()
                    .map(<u64 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::<
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.rx_meta_buf_size
                    .as_ref()
                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 4 > 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 = (4 - 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::<
                UdpMetadataEncodingProtocolVersion,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.metadata_encoding_protocol_version.as_ref().map(
                    <UdpMetadataEncodingProtocolVersion as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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::encoding::HandleType<
                    fidl::Socket,
                    { fidl::ObjectType::SOCKET.into_raw() },
                    2147483648,
                > 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.socket.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, 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 =
                    <u64 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.tx_meta_buf_size.get_or_insert_with(|| {
                    fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    u64,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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 =
                    <u64 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.rx_meta_buf_size.get_or_insert_with(|| {
                    fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    u64,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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 < 4 {
                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 =
                    <UdpMetadataEncodingProtocolVersion 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.metadata_encoding_protocol_version.get_or_insert_with(|| {
                    fidl::new_empty!(
                        UdpMetadataEncodingProtocolVersion,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    UdpMetadataEncodingProtocolVersion,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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 DatagramSocketRecvMsgPostflightResponse {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.requests {
                return 3;
            }
            if let Some(_) = self.timestamp {
                return 2;
            }
            if let Some(_) = self.validity {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DatagramSocketRecvMsgPostflightResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DatagramSocketRecvMsgPostflightResponse {
        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
        fidl::encoding::Encode<
            DatagramSocketRecvMsgPostflightResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DatagramSocketRecvMsgPostflightResponse
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DatagramSocketRecvMsgPostflightResponse>(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::encoding::HandleType<
                    fidl::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    49155,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.validity.as_mut().map(
                    <fidl::encoding::HandleType<
                        fidl::EventPair,
                        { fidl::ObjectType::EVENTPAIR.into_raw() },
                        49155,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_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::<
                TimestampOption,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.timestamp
                    .as_ref()
                    .map(<TimestampOption 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::<
                CmsgRequests,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.requests
                    .as_ref()
                    .map(<CmsgRequests as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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::encoding::HandleType<
                    fidl::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    49155,
                > 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.validity.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 49155>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 49155>, fidl::encoding::DefaultFuchsiaResourceDialect, 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 =
                    <TimestampOption 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.timestamp.get_or_insert_with(|| {
                    fidl::new_empty!(TimestampOption, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    TimestampOption,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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 =
                    <CmsgRequests 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.requests.get_or_insert_with(|| {
                    fidl::new_empty!(CmsgRequests, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    CmsgRequests,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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 DatagramSocketSendMsgPreflightResponse {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.maximum_size {
                return 3;
            }
            if let Some(_) = self.validity {
                return 2;
            }
            if let Some(_) = self.to {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DatagramSocketSendMsgPreflightResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DatagramSocketSendMsgPreflightResponse {
        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
        fidl::encoding::Encode<
            DatagramSocketSendMsgPreflightResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DatagramSocketSendMsgPreflightResponse
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DatagramSocketSendMsgPreflightResponse>(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::SocketAddress,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.to.as_ref().map(
                    <fidl_fuchsia_net::SocketAddress 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::encoding::Vector<
                    fidl::encoding::HandleType<
                        fidl::EventPair,
                        { fidl::ObjectType::EVENTPAIR.into_raw() },
                        49155,
                    >,
                    63,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.validity.as_mut().map(
                    <fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::EventPair,
                            { fidl::ObjectType::EVENTPAIR.into_raw() },
                            49155,
                        >,
                        63,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_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::<
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.maximum_size.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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::SocketAddress 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.to.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl_fuchsia_net::SocketAddress,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl_fuchsia_net::SocketAddress,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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::encoding::Vector<
                    fidl::encoding::HandleType<
                        fidl::EventPair,
                        { fidl::ObjectType::EVENTPAIR.into_raw() },
                        49155,
                    >,
                    63,
                > 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.validity.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Vector<
                            fidl::encoding::HandleType<
                                fidl::EventPair,
                                { fidl::ObjectType::EVENTPAIR.into_raw() },
                                49155,
                            >,
                            63,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Vector<
                        fidl::encoding::HandleType<
                            fidl::EventPair,
                            { fidl::ObjectType::EVENTPAIR.into_raw() },
                            49155,
                        >,
                        63,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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 =
                    <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.maximum_size.get_or_insert_with(|| {
                    fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    u32,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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 SocketCreationOptions {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.group {
                return 2;
            }
            if let Some(_) = self.marks {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for SocketCreationOptions {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for SocketCreationOptions {
        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
        fidl::encoding::Encode<SocketCreationOptions, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut SocketCreationOptions
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SocketCreationOptions>(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::Marks,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.marks
                    .as_ref()
                    .map(<fidl_fuchsia_net::Marks 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_resources::WakeGroupToken, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.group.as_mut().map(<fidl_fuchsia_net_resources::WakeGroupToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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::Marks 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.marks.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl_fuchsia_net::Marks,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl_fuchsia_net::Marks,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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_resources::WakeGroupToken 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.group.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl_fuchsia_net_resources::WakeGroupToken,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl_fuchsia_net_resources::WakeGroupToken,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    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 StreamSocketDescribeResponse {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.socket {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for StreamSocketDescribeResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for StreamSocketDescribeResponse {
        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
        fidl::encoding::Encode<
            StreamSocketDescribeResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut StreamSocketDescribeResponse
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<StreamSocketDescribeResponse>(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::encoding::HandleType<
                    fidl::Socket,
                    { fidl::ObjectType::SOCKET.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.socket.as_mut().map(
                    <fidl::encoding::HandleType<
                        fidl::Socket,
                        { fidl::ObjectType::SOCKET.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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::encoding::HandleType<
                    fidl::Socket,
                    { fidl::ObjectType::SOCKET.into_raw() },
                    2147483648,
                > 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.socket.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, 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 SynchronousDatagramSocketDescribeResponse {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.event {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for SynchronousDatagramSocketDescribeResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for SynchronousDatagramSocketDescribeResponse {
        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
        fidl::encoding::Encode<
            SynchronousDatagramSocketDescribeResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut SynchronousDatagramSocketDescribeResponse
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SynchronousDatagramSocketDescribeResponse>(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::encoding::HandleType<
                    fidl::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.event.as_mut().map(
                    <fidl::encoding::HandleType<
                        fidl::EventPair,
                        { fidl::ObjectType::EVENTPAIR.into_raw() },
                        2147483648,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

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

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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::encoding::HandleType<
                    fidl::EventPair,
                    { fidl::ObjectType::EVENTPAIR.into_raw() },
                    2147483648,
                > 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.event.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, 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::ResourceTypeMarker for ProviderDatagramSocketWithOptionsResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ProviderDatagramSocketWithOptionsResponse {
        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
        fidl::encoding::Encode<
            ProviderDatagramSocketWithOptionsResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ProviderDatagramSocketWithOptionsResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProviderDatagramSocketWithOptionsResponse>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            ProviderDatagramSocketWithOptionsResponse::DatagramSocket(ref mut val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            ProviderDatagramSocketWithOptionsResponse::SynchronousDatagramSocket(ref mut val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
        }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ProviderDatagramSocketWithOptionsResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::DatagramSocket(fidl::new_empty!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect
            ))
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            2 => <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            _ => return Err(fidl::Error::UnknownUnionTag),
        };

            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 ProviderDatagramSocketWithOptionsResponse::DatagramSocket(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ProviderDatagramSocketWithOptionsResponse::DatagramSocket(
                            fidl::new_empty!(
                                fidl::encoding::Endpoint<
                                    fidl::endpoints::ClientEnd<DatagramSocketMarker>,
                                >,
                                fidl::encoding::DefaultFuchsiaResourceDialect
                            ),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ProviderDatagramSocketWithOptionsResponse::DatagramSocket(ref mut val) =
                        self
                    {
                        fidl::decode!(
                            fidl::encoding::Endpoint<
                                fidl::endpoints::ClientEnd<DatagramSocketMarker>,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ProviderDatagramSocketWithOptionsResponse::SynchronousDatagramSocket(_) =
                        self
                    {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self =
                            ProviderDatagramSocketWithOptionsResponse::SynchronousDatagramSocket(
                                fidl::new_empty!(
                                    fidl::encoding::Endpoint<
                                        fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
                                    >,
                                    fidl::encoding::DefaultFuchsiaResourceDialect
                                ),
                            );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ProviderDatagramSocketWithOptionsResponse::SynchronousDatagramSocket(
                        ref mut val,
                    ) = self
                    {
                        fidl::decode!(
                            fidl::encoding::Endpoint<
                                fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected 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::ResourceTypeMarker for ProviderDatagramSocketResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ProviderDatagramSocketResponse {
        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
        fidl::encoding::Encode<
            ProviderDatagramSocketResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ProviderDatagramSocketResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ProviderDatagramSocketResponse>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            ProviderDatagramSocketResponse::DatagramSocket(ref mut val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            ProviderDatagramSocketResponse::SynchronousDatagramSocket(ref mut val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
        }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ProviderDatagramSocketResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::DatagramSocket(fidl::new_empty!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect
            ))
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            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::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            2 => <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            _ => return Err(fidl::Error::UnknownUnionTag),
        };

            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 ProviderDatagramSocketResponse::DatagramSocket(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ProviderDatagramSocketResponse::DatagramSocket(fidl::new_empty!(
                            fidl::encoding::Endpoint<
                                fidl::endpoints::ClientEnd<DatagramSocketMarker>,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ProviderDatagramSocketResponse::DatagramSocket(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::Endpoint<
                                fidl::endpoints::ClientEnd<DatagramSocketMarker>,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let ProviderDatagramSocketResponse::SynchronousDatagramSocket(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = ProviderDatagramSocketResponse::SynchronousDatagramSocket(
                            fidl::new_empty!(
                                fidl::encoding::Endpoint<
                                    fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
                                >,
                                fidl::encoding::DefaultFuchsiaResourceDialect
                            ),
                        );
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let ProviderDatagramSocketResponse::SynchronousDatagramSocket(ref mut val) =
                        self
                    {
                        fidl::decode!(
                            fidl::encoding::Endpoint<
                                fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
                            >,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected 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(())
        }
    }
}